@indiekitai/pg-dash 0.2.0 → 0.3.1

package/dist/cli.js

@@ -47,7 +47,7 @@ function computeBreakdown(issues) {
   }
   return result;
 }
-async function getAdvisorReport(pool) {
+async function getAdvisorReport(pool, longQueryThreshold = 5) {
   const client = await pool.connect();
   const issues = [];
   try {
@@ -281,9 +281,9 @@ SHOW shared_buffers;`,
           extract(epoch from now() - state_change)::int AS idle_seconds
         FROM pg_stat_activity
         WHERE state IN ('idle', 'idle in transaction')
-          AND now() - state_change > interval '10 minutes'
+          AND now() - state_change > $1 * interval '1 minute'
           AND pid != pg_backend_pid()
-      `);
+      `, [longQueryThreshold]);
       for (const row of r.rows) {
         const isIdleTx = row.state === "idle in transaction";
         issues.push({
@@ -777,42 +777,214 @@ async function getActivity(pool) {
   }
 }
 
-// src/server/queries/slow-queries.ts
-async function getSlowQueries(pool) {
-  const client = await pool.connect();
-  try {
-    const extCheck = await client.query(
-      "SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'"
-    );
-    if (extCheck.rows.length === 0) {
-      return [];
+// src/server/index.ts
+init_advisor();
+
+// src/server/timeseries.ts
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
+var DEFAULT_DIR = path.join(os.homedir(), ".pg-dash");
+var DEFAULT_RETENTION_DAYS = 7;
+var TimeseriesStore = class {
+  db;
+  insertStmt;
+  retentionMs;
+  constructor(dbOrDir, retentionDays = DEFAULT_RETENTION_DAYS) {
+    if (dbOrDir instanceof Database) {
+      this.db = dbOrDir;
+    } else {
+      const dir = dbOrDir || DEFAULT_DIR;
+      fs.mkdirSync(dir, { recursive: true });
+      const dbPath = path.join(dir, "metrics.db");
+      this.db = new Database(dbPath);
     }
-    const r = await client.query(`
-      SELECT
-        queryid::text,
-        query,
-        calls::int,
-        total_exec_time AS total_time,
-        mean_exec_time AS mean_time,
-        rows::int,
-        round(total_exec_time::numeric / 1000, 2)::text || 's' AS total_time_pretty,
-        round(mean_exec_time::numeric, 2)::text || 'ms' AS mean_time_pretty
-      FROM pg_stat_statements
-      WHERE query NOT LIKE '%pg_stat%'
-        AND query NOT LIKE '%pg_catalog%'
-      ORDER BY total_exec_time DESC
-      LIMIT 50
+    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);
     `);
-    return r.rows;
-  } catch {
-    return [];
-  } finally {
-    client.release();
+    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/index.ts
-init_advisor();
+// 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 = {};
+  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;
+    }
+    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) {
@@ -1024,203 +1196,20 @@ async function getSchemaEnums(pool) {
   }
 }
 
-// src/server/timeseries.ts
-import Database from "better-sqlite3";
-import path from "path";
-import os from "os";
-import fs from "fs";
-var DEFAULT_DIR = path.join(os.homedir(), ".pg-dash");
-var DEFAULT_RETENTION_DAYS = 7;
-var TimeseriesStore = class {
-  db;
-  insertStmt;
-  retentionMs;
-  constructor(dataDir, retentionDays = DEFAULT_RETENTION_DAYS) {
-    const dir = dataDir || DEFAULT_DIR;
-    fs.mkdirSync(dir, { recursive: true });
-    const dbPath = path.join(dir, "metrics.db");
-    this.db = new Database(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 (?, ?, ?)"
-    );
+// 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` });
+    }
   }
-  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
-var Collector = class {
-  constructor(pool, store, intervalMs = 3e4) {
-    this.pool = pool;
-    this.store = store;
-    this.intervalMs = intervalMs;
-  }
-  timer = null;
-  prev = null;
-  lastSnapshot = {};
-  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);
-    setInterval(() => this.store.prune(), 60 * 60 * 1e3);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = 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 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;
-    }
-    const points = Object.entries(snapshot).map(([metric, value]) => ({
-      timestamp: now,
-      metric,
-      value
-    }));
-    if (points.length > 0) {
-      this.store.insertMany(points);
-    }
-    this.lastSnapshot = snapshot;
-    return snapshot;
-  }
-};
-
-// 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] 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);
@@ -1426,6 +1415,92 @@ var SchemaTracker = class {
   }
 };
 
+// src/server/notifiers.ts
+var SEVERITY_COLORS = {
+  critical: { hex: "#e74c3c", decimal: 15158332, emoji: "\u{1F534}" },
+  warning: { hex: "#f39c12", decimal: 15965202, emoji: "\u{1F7E1}" },
+  info: { hex: "#3498db", decimal: 3447003, emoji: "\u{1F535}" }
+};
+function detectWebhookType(url) {
+  if (url.includes("hooks.slack.com")) return "slack";
+  if (url.includes("discord.com/api/webhooks") || url.includes("discordapp.com")) return "discord";
+  return "generic";
+}
+function formatSlackMessage(alert, rule) {
+  const colors = SEVERITY_COLORS[rule.severity] || SEVERITY_COLORS.info;
+  return {
+    attachments: [
+      {
+        color: colors.hex,
+        blocks: [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `${colors.emoji} *pg-dash Alert: ${rule.name}*`
+            }
+          },
+          {
+            type: "section",
+            fields: [
+              { type: "mrkdwn", text: `*Metric:*
+${rule.metric}` },
+              { type: "mrkdwn", text: `*Current Value:*
+${alert.value}` },
+              { type: "mrkdwn", text: `*Threshold:*
+${rule.operator} ${rule.threshold}` },
+              { type: "mrkdwn", text: `*Severity:*
+${rule.severity}` },
+              { type: "mrkdwn", text: `*Timestamp:*
+${new Date(alert.timestamp).toISOString()}` }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}
+function formatDiscordMessage(alert, rule) {
+  const colors = SEVERITY_COLORS[rule.severity] || SEVERITY_COLORS.info;
+  return {
+    embeds: [
+      {
+        title: `${colors.emoji} pg-dash Alert: ${rule.name}`,
+        color: colors.decimal,
+        fields: [
+          { name: "Metric", value: rule.metric, inline: true },
+          { name: "Current Value", value: String(alert.value), inline: true },
+          { name: "Threshold", value: `${rule.operator} ${rule.threshold}`, inline: true },
+          { name: "Severity", value: rule.severity, inline: true },
+          { name: "Timestamp", value: new Date(alert.timestamp).toISOString(), inline: false }
+        ],
+        footer: { text: "pg-dash \xB7 PostgreSQL Monitoring" }
+      }
+    ]
+  };
+}
+function formatGenericWebhook(alert, rule) {
+  return {
+    severity: rule.severity,
+    rule: rule.name,
+    metric: rule.metric,
+    value: alert.value,
+    message: alert.message,
+    timestamp: alert.timestamp
+  };
+}
+function formatWebhookPayload(alert, rule, webhookUrl) {
+  const type = detectWebhookType(webhookUrl);
+  switch (type) {
+    case "slack":
+      return formatSlackMessage(alert, rule);
+    case "discord":
+      return formatDiscordMessage(alert, rule);
+    default:
+      return formatGenericWebhook(alert, rule);
+  }
+}
+
 // src/server/alerts.ts
 var DEFAULT_RULES = [
   { name: "Connection utilization > 80%", metric: "connection_util", operator: "gt", threshold: 80, severity: "warning", enabled: 1, cooldown_minutes: 60 },
@@ -1434,7 +1509,9 @@ var DEFAULT_RULES = [
   { name: "Cache hit ratio < 95%", metric: "cache_hit_pct", operator: "lt", threshold: 95, severity: "critical", enabled: 1, cooldown_minutes: 30 },
   { name: "Long-running query > 5 min", metric: "long_query_count", operator: "gt", threshold: 0, severity: "warning", enabled: 1, cooldown_minutes: 15 },
   { name: "Idle in transaction > 10 min", metric: "idle_in_tx_count", operator: "gt", threshold: 0, severity: "warning", enabled: 1, cooldown_minutes: 15 },
-  { name: "Health score below D", metric: "health_score", operator: "lt", threshold: 50, severity: "warning", enabled: 1, cooldown_minutes: 120 }
+  { name: "Health score below D", metric: "health_score", operator: "lt", threshold: 50, severity: "warning", enabled: 1, cooldown_minutes: 120 },
+  { name: "Database size growth > 10% in 24h", metric: "db_growth_pct_24h", operator: "gt", threshold: 10, severity: "warning", enabled: 1, cooldown_minutes: 60 },
+  { name: "Predicted disk full within 7 days", metric: "days_until_full", operator: "lt", threshold: 7, severity: "critical", enabled: 1, cooldown_minutes: 360 }
 ];
 var AlertManager = class {
   db;
@@ -1563,20 +1640,55 @@ var AlertManager = class {
         return false;
     }
   }
+  getWebhookUrl() {
+    return this.webhookUrl;
+  }
+  getWebhookType() {
+    if (!this.webhookUrl) return null;
+    return detectWebhookType(this.webhookUrl);
+  }
+  async sendTestWebhook() {
+    if (!this.webhookUrl) return { ok: false, type: "none", error: "No webhook URL configured" };
+    const type = detectWebhookType(this.webhookUrl);
+    const testRule = {
+      id: 0,
+      name: "Test Alert",
+      metric: "test_metric",
+      operator: "gt",
+      threshold: 80,
+      severity: "info",
+      enabled: 1,
+      cooldown_minutes: 60
+    };
+    const testEntry = {
+      id: 0,
+      rule_id: 0,
+      timestamp: Date.now(),
+      value: 85,
+      message: "Test Alert: test_metric = 85 (threshold: gt 80)",
+      notified: 0
+    };
+    try {
+      const payload = formatWebhookPayload(testEntry, testRule, this.webhookUrl);
+      const res = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok) return { ok: false, type, error: `HTTP ${res.status}` };
+      return { ok: true, type };
+    } catch (err) {
+      return { ok: false, type, error: err.message };
+    }
+  }
   async sendWebhook(rule, entry) {
     if (!this.webhookUrl) return;
     try {
+      const payload = formatWebhookPayload(entry, rule, this.webhookUrl);
       await fetch(this.webhookUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          severity: rule.severity,
-          rule: rule.name,
-          metric: rule.metric,
-          value: entry.value,
-          message: entry.message,
-          timestamp: entry.timestamp
-        })
+        body: JSON.stringify(payload)
       });
       this.db.prepare("UPDATE alert_history SET notified = 1 WHERE id = ?").run(entry.id);
     } catch (err) {
@@ -1585,11 +1697,32 @@ var AlertManager = class {
   }
 };
 
-// src/server/index.ts
-import Database2 from "better-sqlite3";
-import { WebSocketServer, WebSocket } from "ws";
-import http from "http";
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+// src/server/routes/overview.ts
+function registerOverviewRoutes(app, pool) {
+  app.get("/api/overview", async (c) => {
+    try {
+      return c.json(await getOverview(pool));
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/databases", async (c) => {
+    try {
+      return c.json(await getDatabases(pool));
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/tables", async (c) => {
+    try {
+      return c.json(await getTables(pool));
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
+// src/server/routes/metrics.ts
 var RANGE_MAP = {
   "5m": 5 * 60 * 1e3,
   "15m": 15 * 60 * 1e3,
@@ -1598,103 +1731,18 @@ var RANGE_MAP = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3
 };
-async function startServer(opts) {
-  const pool = new Pool({ connectionString: opts.connectionString });
-  try {
-    const client = await pool.connect();
-    client.release();
-  } catch (err) {
-    console.error(`Failed to connect to PostgreSQL: ${err.message}`);
-    process.exit(1);
-  }
-  if (opts.json) {
+function registerMetricsRoutes(app, store, collector) {
+  app.get("/api/metrics", (c) => {
     try {
-      const [overview, advisor, databases, tables] = await Promise.all([
-        getOverview(pool),
-        getAdvisorReport(pool),
-        getDatabases(pool),
-        getTables(pool)
-      ]);
-      console.log(JSON.stringify({ overview, advisor, databases, tables }, null, 2));
+      const metric = c.req.query("metric");
+      const range = c.req.query("range") || "1h";
+      if (!metric) return c.json({ error: "metric param required" }, 400);
+      const rangeMs = RANGE_MAP[range] || RANGE_MAP["1h"];
+      const now = Date.now();
+      const data = store.query(metric, now - rangeMs, now);
+      return c.json(data);
     } catch (err) {
-      console.error(JSON.stringify({ error: err.message }));
-      process.exit(1);
-    }
-    await pool.end();
-    process.exit(0);
-  }
-  const dataDir = opts.dataDir || path2.join(os2.homedir(), ".pg-dash");
-  fs2.mkdirSync(dataDir, { recursive: true });
-  const store = new TimeseriesStore(opts.dataDir, opts.retentionDays);
-  const intervalMs = (opts.interval || 30) * 1e3;
-  const longQueryThreshold = opts.longQueryThreshold || 5;
-  const collector = new Collector(pool, store, intervalMs);
-  console.log(`  Collecting metrics every ${intervalMs / 1e3}s...`);
-  collector.start();
-  const schemaDbPath = path2.join(dataDir, "schema.db");
-  const schemaDb = new Database2(schemaDbPath);
-  schemaDb.pragma("journal_mode = WAL");
-  const snapshotIntervalMs = (opts.snapshotInterval || 6) * 60 * 60 * 1e3;
-  const schemaTracker = new SchemaTracker(schemaDb, pool, snapshotIntervalMs);
-  schemaTracker.start();
-  console.log("  Schema change tracking enabled");
-  const alertsDbPath = path2.join(dataDir, "alerts.db");
-  const alertsDb = new Database2(alertsDbPath);
-  alertsDb.pragma("journal_mode = WAL");
-  const alertManager = new AlertManager(alertsDb, opts.webhook);
-  console.log("  Alert monitoring enabled");
-  const app = new Hono();
-  if (opts.auth || opts.token) {
-    app.use("*", async (c, next) => {
-      const authHeader = c.req.header("authorization") || "";
-      if (opts.token) {
-        if (authHeader === `Bearer ${opts.token}`) return next();
-      }
-      if (opts.auth) {
-        const [user, pass] = opts.auth.split(":");
-        const expected = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
-        if (authHeader === expected) return next();
-      }
-      const url = new URL(c.req.url, "http://localhost");
-      if (opts.token && url.searchParams.get("token") === opts.token) return next();
-      if (opts.auth) {
-        c.header("WWW-Authenticate", 'Basic realm="pg-dash"');
-      }
-      return c.text("Unauthorized", 401);
-    });
-  }
-  app.get("/api/overview", async (c) => {
-    try {
-      return c.json(await getOverview(pool));
-    } catch (err) {
-      return c.json({ error: err.message }, 500);
-    }
-  });
-  app.get("/api/databases", async (c) => {
-    try {
-      return c.json(await getDatabases(pool));
-    } catch (err) {
-      return c.json({ error: err.message }, 500);
-    }
-  });
-  app.get("/api/tables", async (c) => {
-    try {
-      return c.json(await getTables(pool));
-    } catch (err) {
-      return c.json({ error: err.message }, 500);
-    }
-  });
-  app.get("/api/metrics", (c) => {
-    try {
-      const metric = c.req.query("metric");
-      const range = c.req.query("range") || "1h";
-      if (!metric) return c.json({ error: "metric param required" }, 400);
-      const rangeMs = RANGE_MAP[range] || RANGE_MAP["1h"];
-      const now = Date.now();
-      const data = store.query(metric, now - rangeMs, now);
-      return c.json(data);
-    } catch (err) {
-      return c.json({ error: err.message }, 500);
+      return c.json({ error: err.message }, 500);
     }
   });
   app.get("/api/metrics/latest", (_c) => {
@@ -1705,6 +1753,44 @@ async function startServer(opts) {
       return _c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/queries/slow-queries.ts
+async function getSlowQueries(pool) {
+  const client = await pool.connect();
+  try {
+    const extCheck = await client.query(
+      "SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'"
+    );
+    if (extCheck.rows.length === 0) {
+      return [];
+    }
+    const r = await client.query(`
+      SELECT
+        queryid::text,
+        query,
+        calls::int,
+        total_exec_time AS total_time,
+        mean_exec_time AS mean_time,
+        rows::int,
+        round(total_exec_time::numeric / 1000, 2)::text || 's' AS total_time_pretty,
+        round(mean_exec_time::numeric, 2)::text || 'ms' AS mean_time_pretty
+      FROM pg_stat_statements
+      WHERE query NOT LIKE '%pg_stat%'
+        AND query NOT LIKE '%pg_catalog%'
+      ORDER BY total_exec_time DESC
+      LIMIT 50
+    `);
+    return r.rows;
+  } catch {
+    return [];
+  } finally {
+    client.release();
+  }
+}
+
+// src/server/routes/activity.ts
+function registerActivityRoutes(app, pool) {
   app.get("/api/activity", async (c) => {
     try {
       return c.json(await getActivity(pool));
@@ -1733,9 +1819,14 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/routes/advisor.ts
+init_advisor();
+function registerAdvisorRoutes(app, pool, longQueryThreshold) {
   app.get("/api/advisor", async (c) => {
     try {
-      return c.json(await getAdvisorReport(pool));
+      return c.json(await getAdvisorReport(pool, longQueryThreshold));
     } catch (err) {
       return c.json({ error: err.message }, 500);
     }
@@ -1759,6 +1850,10 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/routes/schema.ts
+function registerSchemaRoutes(app, pool, schemaTracker) {
   app.get("/api/schema/tables", async (c) => {
     try {
       return c.json(await getSchemaTables(pool));
@@ -1847,6 +1942,10 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/routes/alerts.ts
+function registerAlertsRoutes(app, alertManager) {
   app.get("/api/alerts/rules", (c) => {
     try {
       return c.json(alertManager.getRules());
@@ -1884,6 +1983,24 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/alerts/webhook-info", (c) => {
+    try {
+      const url = alertManager.getWebhookUrl();
+      const type = alertManager.getWebhookType();
+      const masked = url ? url.replace(/\/[^/]{8,}$/, "/****") : null;
+      return c.json({ url: masked, type: type || "none", configured: !!url });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/api/alerts/test-webhook", async (c) => {
+    try {
+      const result = await alertManager.sendTestWebhook();
+      return c.json(result, result.ok ? 200 : 400);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
   app.get("/api/alerts/history", (c) => {
     try {
       const limit = parseInt(c.req.query("limit") || "50");
@@ -1892,6 +2009,513 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/routes/explain.ts
+var DDL_PATTERN = /\b(CREATE|DROP|ALTER|TRUNCATE|GRANT|REVOKE)\b/i;
+function registerExplainRoutes(app, pool) {
+  app.post("/api/explain", async (c) => {
+    try {
+      const body = await c.req.json();
+      const query = body?.query?.trim();
+      if (!query) return c.json({ error: "Missing query" }, 400);
+      if (DDL_PATTERN.test(query)) return c.json({ error: "DDL statements are not allowed" }, 400);
+      if (!/^\s*SELECT\b/i.test(query)) return c.json({ error: "Only SELECT queries can be explained for safety. DELETE/UPDATE/INSERT are blocked." }, 400);
+      const client = await pool.connect();
+      try {
+        await client.query("SET statement_timeout = '30s'");
+        await client.query("BEGIN");
+        try {
+          const r = await client.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${query}`);
+          await client.query("ROLLBACK");
+          await client.query("RESET statement_timeout");
+          return c.json({ plan: r.rows[0]["QUERY PLAN"] });
+        } catch (err) {
+          await client.query("ROLLBACK").catch(() => {
+          });
+          await client.query("RESET statement_timeout").catch(() => {
+          });
+          return c.json({ error: err.message }, 400);
+        }
+      } finally {
+        client.release();
+      }
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
+// src/server/disk-prediction.ts
+function linearRegression(points) {
+  const n = points.length;
+  if (n < 2) return { slope: 0, intercept: 0, r2: 0 };
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
+  for (const p of points) {
+    sumX += p.x;
+    sumY += p.y;
+    sumXY += p.x * p.y;
+    sumX2 += p.x * p.x;
+    sumY2 += p.y * p.y;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0) return { slope: 0, intercept: sumY / n, r2: 0 };
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const meanY = sumY / n;
+  let ssTot = 0, ssRes = 0;
+  for (const p of points) {
+    ssTot += (p.y - meanY) ** 2;
+    ssRes += (p.y - (slope * p.x + intercept)) ** 2;
+  }
+  const r2 = ssTot === 0 ? 1 : Math.max(0, 1 - ssRes / ssTot);
+  return { slope, intercept, r2 };
+}
+var DiskPredictor = class {
+  /**
+   * Predict disk growth based on historical metric data.
+   * @param store TimeseriesStore instance
+   * @param metric Metric name (e.g. "db_size_bytes")
+   * @param daysAhead How many days to project ahead
+   * @param maxDiskBytes Optional max disk capacity for "days until full" calc
+   */
+  predict(store, metric, daysAhead, maxDiskBytes) {
+    const now = Date.now();
+    const data = store.query(metric, now - 30 * 24 * 60 * 60 * 1e3, now);
+    if (data.length < 2) return null;
+    const timeSpanMs = data[data.length - 1].timestamp - data[0].timestamp;
+    if (timeSpanMs < 24 * 60 * 60 * 1e3) return null;
+    const currentBytes = data[data.length - 1].value;
+    const t0 = data[0].timestamp;
+    const points = data.map((d) => ({
+      x: (d.timestamp - t0) / (24 * 60 * 60 * 1e3),
+      // days
+      y: d.value
+    }));
+    const { slope, r2 } = linearRegression(points);
+    const growthRatePerDay = slope;
+    let predictedFullDate = null;
+    let daysUntilFull = null;
+    if (maxDiskBytes && growthRatePerDay > 0) {
+      const remainingBytes = maxDiskBytes - currentBytes;
+      daysUntilFull = remainingBytes / growthRatePerDay;
+      if (daysUntilFull > 0 && daysUntilFull < 365 * 10) {
+        predictedFullDate = new Date(now + daysUntilFull * 24 * 60 * 60 * 1e3);
+      }
+    }
+    return {
+      currentBytes,
+      growthRatePerDay,
+      predictedFullDate,
+      daysUntilFull: daysUntilFull !== null && daysUntilFull > 0 ? daysUntilFull : null,
+      confidence: r2
+    };
+  }
+};
+
+// src/server/routes/disk.ts
+var RANGE_MAP2 = {
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3
+};
+function registerDiskRoutes(app, pool, store) {
+  const predictor = new DiskPredictor();
+  app.get("/api/disk/usage", async (c) => {
+    try {
+      const client = await pool.connect();
+      try {
+        const dbRes = await client.query(`
+          SELECT pg_database_size(current_database()) AS db_size,
+                 (SELECT setting FROM pg_settings WHERE name = 'data_directory') AS data_dir
+        `);
+        const { db_size, data_dir } = dbRes.rows[0];
+        const tsRes = await client.query(`SELECT spcname, pg_tablespace_size(oid) AS size FROM pg_tablespace`);
+        const tablespaces = tsRes.rows.map((r) => ({
+          name: r.spcname,
+          size: parseInt(r.size)
+        }));
+        const tableRes = await client.query(`
+          SELECT schemaname, relname,
+                 pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as total_size,
+                 pg_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as table_size,
+                 pg_indexes_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as index_size
+          FROM pg_stat_user_tables
+          ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
+          LIMIT 20
+        `);
+        const tables = tableRes.rows.map((r) => ({
+          schema: r.schemaname,
+          name: r.relname,
+          totalSize: parseInt(r.total_size),
+          tableSize: parseInt(r.table_size),
+          indexSize: parseInt(r.index_size)
+        }));
+        return c.json({
+          dbSize: parseInt(db_size),
+          dataDir: data_dir,
+          tablespaces,
+          tables
+        });
+      } finally {
+        client.release();
+      }
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/disk/prediction", (c) => {
+    try {
+      const days = parseInt(c.req.query("days") || "30");
+      const maxDisk = c.req.query("maxDisk") ? parseInt(c.req.query("maxDisk")) : void 0;
+      const prediction = predictor.predict(store, "db_size_bytes", days, maxDisk);
+      return c.json({ prediction });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/disk/history", (c) => {
+    try {
+      const range = c.req.query("range") || "24h";
+      const rangeMs = RANGE_MAP2[range] || RANGE_MAP2["24h"];
+      const now = Date.now();
+      const data = store.query("db_size_bytes", now - rangeMs, now);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
+// src/server/query-stats.ts
+var DEFAULT_RETENTION_DAYS2 = 7;
+var QueryStatsStore = class {
+  db;
+  insertStmt;
+  retentionMs;
+  prev = /* @__PURE__ */ new Map();
+  timer = null;
+  pruneTimer = null;
+  constructor(db, retentionDays = DEFAULT_RETENTION_DAYS2) {
+    this.db = db;
+    this.retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS query_stats (
+        timestamp INTEGER NOT NULL,
+        queryid TEXT NOT NULL,
+        query TEXT,
+        calls INTEGER,
+        total_exec_time REAL,
+        mean_exec_time REAL,
+        min_exec_time REAL,
+        max_exec_time REAL,
+        rows INTEGER,
+        shared_blks_hit INTEGER,
+        shared_blks_read INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_qs_queryid_ts ON query_stats(queryid, timestamp);
+    `);
+    this.insertStmt = this.db.prepare(
+      `INSERT INTO query_stats (timestamp, queryid, query, calls, total_exec_time, mean_exec_time, min_exec_time, max_exec_time, rows, shared_blks_hit, shared_blks_read)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+  }
+  startPeriodicSnapshot(pool, intervalMs = 5 * 60 * 1e3) {
+    this.snapshot(pool).catch(
+      (err) => console.error("[query-stats] Initial snapshot failed:", err.message)
+    );
+    this.timer = setInterval(() => {
+      this.snapshot(pool).catch(
+        (err) => console.error("[query-stats] Snapshot failed:", err.message)
+      );
+    }, intervalMs);
+    this.pruneTimer = setInterval(() => this.prune(), 60 * 60 * 1e3);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+      this.pruneTimer = null;
+    }
+  }
+  async snapshot(pool) {
+    const client = await pool.connect();
+    try {
+      const extCheck = await client.query(
+        "SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'"
+      );
+      if (extCheck.rows.length === 0) return 0;
+      const r = await client.query(`
+        SELECT
+          queryid::text,
+          query,
+          calls::int,
+          total_exec_time,
+          mean_exec_time,
+          min_exec_time,
+          max_exec_time,
+          rows::int,
+          shared_blks_hit::int,
+          shared_blks_read::int
+        FROM pg_stat_statements
+        WHERE query NOT LIKE '%pg_stat%'
+          AND query NOT LIKE '%pg_catalog%'
+          AND queryid IS NOT NULL
+      `);
+      const now = Date.now();
+      const hasPrev = this.prev.size > 0;
+      let count = 0;
+      const tx = this.db.transaction((rows) => {
+        for (const row of rows) {
+          const prev = this.prev.get(row.queryid);
+          if (hasPrev && prev) {
+            const deltaCalls = Math.max(0, row.calls - prev.calls);
+            if (deltaCalls === 0) continue;
+            const deltaTime = Math.max(0, row.total_exec_time - prev.total_exec_time);
+            const deltaRows = Math.max(0, row.rows - prev.rows);
+            const deltaHit = Math.max(0, row.shared_blks_hit - prev.shared_blks_hit);
+            const deltaRead = Math.max(0, row.shared_blks_read - prev.shared_blks_read);
+            const meanTime = deltaCalls > 0 ? deltaTime / deltaCalls : 0;
+            this.insertStmt.run(
+              now,
+              row.queryid,
+              row.query,
+              deltaCalls,
+              deltaTime,
+              meanTime,
+              row.min_exec_time,
+              row.max_exec_time,
+              deltaRows,
+              deltaHit,
+              deltaRead
+            );
+            count++;
+          } else if (!hasPrev) {
+            this.insertStmt.run(
+              now,
+              row.queryid,
+              row.query,
+              row.calls,
+              row.total_exec_time,
+              row.mean_exec_time,
+              row.min_exec_time,
+              row.max_exec_time,
+              row.rows,
+              row.shared_blks_hit,
+              row.shared_blks_read
+            );
+            count++;
+          }
+        }
+      });
+      tx(r.rows);
+      this.prev.clear();
+      for (const row of r.rows) {
+        this.prev.set(row.queryid, row);
+      }
+      return count;
+    } catch (err) {
+      console.error("[query-stats] Error snapshotting:", err.message);
+      return 0;
+    } finally {
+      client.release();
+    }
+  }
+  /** Insert a row directly (for testing) */
+  insertRow(row) {
+    this.insertStmt.run(
+      row.timestamp,
+      row.queryid,
+      row.query,
+      row.calls,
+      row.total_exec_time,
+      row.mean_exec_time,
+      row.min_exec_time,
+      row.max_exec_time,
+      row.rows,
+      row.shared_blks_hit,
+      row.shared_blks_read
+    );
+  }
+  getTrend(queryid, startMs, endMs) {
+    const end = endMs ?? Date.now();
+    return this.db.prepare(
+      `SELECT timestamp, queryid, query, calls, total_exec_time, mean_exec_time,
+                min_exec_time, max_exec_time, rows, shared_blks_hit, shared_blks_read
+         FROM query_stats
+         WHERE queryid = ? AND timestamp >= ? AND timestamp <= ?
+         ORDER BY timestamp`
+    ).all(queryid, startMs, end);
+  }
+  getTopQueries(startMs, endMs, orderBy = "total_time", limit = 20) {
+    const orderCol = orderBy === "total_time" ? "SUM(total_exec_time)" : orderBy === "calls" ? "SUM(calls)" : "AVG(mean_exec_time)";
+    return this.db.prepare(
+      `SELECT queryid, 
+                MAX(query) as query,
+                SUM(calls) as total_calls,
+                SUM(total_exec_time) as total_exec_time,
+                AVG(mean_exec_time) as mean_exec_time,
+                SUM(rows) as total_rows
+         FROM query_stats
+         WHERE timestamp >= ? AND timestamp <= ?
+         GROUP BY queryid
+         ORDER BY ${orderCol} DESC
+         LIMIT ?`
+    ).all(startMs, endMs, limit);
+  }
+  prune(retentionMs) {
+    const cutoff = Date.now() - (retentionMs ?? this.retentionMs);
+    const info = this.db.prepare("DELETE FROM query_stats WHERE timestamp < ?").run(cutoff);
+    return info.changes;
+  }
+  close() {
+  }
+};
+
+// src/server/routes/query-stats.ts
+var RANGE_MAP3 = {
+  "1h": 60 * 60 * 1e3,
+  "6h": 6 * 60 * 60 * 1e3,
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3
+};
+function registerQueryStatsRoutes(app, store) {
+  app.get("/api/query-stats/top", (c) => {
+    try {
+      const range = c.req.query("range") || "1h";
+      const orderBy = c.req.query("orderBy") || "total_time";
+      const limit = parseInt(c.req.query("limit") || "20", 10);
+      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["1h"];
+      const now = Date.now();
+      const data = store.getTopQueries(now - rangeMs, now, orderBy, limit);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/query-stats/trend/:queryid", (c) => {
+    try {
+      const queryid = c.req.param("queryid");
+      const range = c.req.query("range") || "1h";
+      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["1h"];
+      const now = Date.now();
+      const data = store.getTrend(queryid, now - rangeMs, now);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
+// src/server/index.ts
+import Database2 from "better-sqlite3";
+import { WebSocketServer, WebSocket } from "ws";
+import http from "http";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+async function startServer(opts) {
+  const pool = new Pool({ connectionString: opts.connectionString });
+  try {
+    const client = await pool.connect();
+    client.release();
+  } catch (err) {
+    console.error(`Failed to connect to PostgreSQL: ${err.message}`);
+    process.exit(1);
+  }
+  const longQueryThreshold = opts.longQueryThreshold || 5;
+  const diskPredictor = new DiskPredictor();
+  if (opts.json) {
+    try {
+      const [overview, advisor, databases, tables] = await Promise.all([
+        getOverview(pool),
+        getAdvisorReport(pool, longQueryThreshold),
+        getDatabases(pool),
+        getTables(pool)
+      ]);
+      console.log(JSON.stringify({ overview, advisor, databases, tables }, null, 2));
+    } catch (err) {
+      console.error(JSON.stringify({ error: err.message }));
+      process.exit(1);
+    }
+    await pool.end();
+    process.exit(0);
+  }
+  const dataDir = opts.dataDir || path2.join(os2.homedir(), ".pg-dash");
+  fs2.mkdirSync(dataDir, { recursive: true });
+  const metricsDbPath = path2.join(dataDir, "metrics.db");
+  const metricsDb = new Database2(metricsDbPath);
+  metricsDb.pragma("journal_mode = WAL");
+  const store = new TimeseriesStore(metricsDb, opts.retentionDays);
+  const intervalMs = (opts.interval || 30) * 1e3;
+  const collector = new Collector(pool, store, intervalMs);
+  console.log(`  Collecting metrics every ${intervalMs / 1e3}s...`);
+  collector.start();
+  const schemaDbPath = path2.join(dataDir, "schema.db");
+  const schemaDb = new Database2(schemaDbPath);
+  schemaDb.pragma("journal_mode = WAL");
+  const snapshotIntervalMs = (opts.snapshotInterval || 6) * 60 * 60 * 1e3;
+  const schemaTracker = new SchemaTracker(schemaDb, pool, snapshotIntervalMs);
+  schemaTracker.start();
+  console.log("  Schema change tracking enabled");
+  const alertsDbPath = path2.join(dataDir, "alerts.db");
+  const alertsDb = new Database2(alertsDbPath);
+  alertsDb.pragma("journal_mode = WAL");
+  const alertManager = new AlertManager(alertsDb, opts.webhook);
+  console.log("  Alert monitoring enabled");
+  const queryStatsStore = new QueryStatsStore(metricsDb, opts.retentionDays);
+  const querySnapshotIntervalMs = (opts.queryStatsInterval || 5) * 60 * 1e3;
+  queryStatsStore.startPeriodicSnapshot(pool, querySnapshotIntervalMs);
+  console.log(`  Query stats snapshots every ${querySnapshotIntervalMs / 6e4}m`);
+  const app = new Hono();
+  if (opts.token) {
+    app.post("/api/auth", async (c) => {
+      try {
+        const body = await c.req.json();
+        if (body?.token === opts.token) {
+          c.header("Set-Cookie", `pg-dash-token=${opts.token}; Path=/; HttpOnly; SameSite=Strict; Max-Age=86400`);
+          return c.json({ ok: true });
+        }
+        return c.json({ error: "Invalid token" }, 401);
+      } catch {
+        return c.json({ error: "Invalid request" }, 400);
+      }
+    });
+  }
+  if (opts.auth || opts.token) {
+    app.use("*", async (c, next) => {
+      const authHeader = c.req.header("authorization") || "";
+      if (opts.token) {
+        if (authHeader === `Bearer ${opts.token}`) return next();
+      }
+      if (opts.auth) {
+        const [user, pass] = opts.auth.split(":");
+        const expected = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
+        if (authHeader === expected) return next();
+      }
+      const url = new URL(c.req.url, "http://localhost");
+      if (opts.token && url.searchParams.get("token") === opts.token) return next();
+      if (opts.token) {
+        const cookies = c.req.header("cookie") || "";
+        const match = cookies.match(/(?:^|;\s*)pg-dash-token=([^;]*)/);
+        if (match && match[1] === opts.token) return next();
+      }
+      if (opts.auth) {
+        c.header("WWW-Authenticate", 'Basic realm="pg-dash"');
+      }
+      return c.text("Unauthorized", 401);
+    });
+  }
+  registerOverviewRoutes(app, pool);
+  registerMetricsRoutes(app, store, collector);
+  registerActivityRoutes(app, pool);
+  registerAdvisorRoutes(app, pool, longQueryThreshold);
+  registerSchemaRoutes(app, pool, schemaTracker);
+  registerAlertsRoutes(app, alertManager);
+  registerExplainRoutes(app, pool);
+  registerDiskRoutes(app, pool, store);
+  registerQueryStatsRoutes(app, queryStatsStore);
   const uiPath = path2.resolve(__dirname, "ui");
   const MIME_TYPES = {
     ".html": "text/html",
@@ -1960,6 +2584,11 @@ async function startServer(opts) {
         const expected = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
         if (authHeader === expected) return cb(true);
       }
+      if (opts.token) {
+        const cookies = info.req.headers["cookie"] || "";
+        const match = cookies.match(/(?:^|;\s*)pg-dash-token=([^;]*)/);
+        if (match && match[1] === opts.token) return cb(true);
+      }
       cb(false, 401, "Unauthorized");
     } : void 0
   });
@@ -1974,9 +2603,7 @@ async function startServer(opts) {
     ws.on("error", () => clients.delete(ws));
   });
   let collectCycleCount = 0;
-  const origCollect = collector.collect.bind(collector);
-  collector.collect = async () => {
-    const snapshot = await origCollect();
+  collector.on("collected", async (snapshot) => {
     if (clients.size > 0 && Object.keys(snapshot).length > 0) {
       const metricsMsg = JSON.stringify({ type: "metrics", data: snapshot });
       let activityData = [];
@@ -2012,7 +2639,7 @@ async function startServer(opts) {
         try {
           const client = await pool.connect();
           try {
-            const r = await client.query(`SELECT count(*)::int AS c FROM pg_stat_activity WHERE state = 'active' AND now() - query_start > interval '${longQueryThreshold} minutes' AND pid != pg_backend_pid()`);
+            const r = await client.query(`SELECT count(*)::int AS c FROM pg_stat_activity WHERE state = 'active' AND now() - query_start > $1 * interval '1 minute' AND pid != pg_backend_pid()`, [longQueryThreshold]);
             alertMetrics.long_query_count = r.rows[0]?.c || 0;
           } finally {
             client.release();
@@ -2023,7 +2650,7 @@ async function startServer(opts) {
         try {
           const client = await pool.connect();
           try {
-            const r = await client.query("SELECT count(*)::int AS c FROM pg_stat_activity WHERE state = 'idle in transaction' AND now() - state_change > interval '10 minutes'");
+            const r = await client.query(`SELECT count(*)::int AS c FROM pg_stat_activity WHERE state = 'idle in transaction' AND now() - state_change > $1 * interval '1 minute'`, [longQueryThreshold]);
             alertMetrics.idle_in_tx_count = r.rows[0]?.c || 0;
           } finally {
             client.release();
@@ -2034,11 +2661,33 @@ async function startServer(opts) {
         collectCycleCount++;
         if (collectCycleCount % 10 === 0) {
           try {
-            const report = await getAdvisorReport(pool);
+            const report = await getAdvisorReport(pool, longQueryThreshold);
             alertMetrics.health_score = report.score;
           } catch (err) {
             console.error("[alerts] Error checking health score:", err.message);
           }
+          try {
+            if (snapshot.db_size_bytes !== void 0) {
+              const dayAgo = Date.now() - 24 * 60 * 60 * 1e3;
+              const oldData = store.query("db_size_bytes", dayAgo, dayAgo + 5 * 60 * 1e3);
+              if (oldData.length > 0) {
+                const oldVal = oldData[0].value;
+                if (oldVal > 0) {
+                  alertMetrics.db_growth_pct_24h = (snapshot.db_size_bytes - oldVal) / oldVal * 100;
+                }
+              }
+            }
+          } catch (err) {
+            console.error("[alerts] Error computing db_growth_pct_24h:", err.message);
+          }
+          try {
+            const pred = diskPredictor.predict(store, "db_size_bytes", 30);
+            if (pred?.daysUntilFull !== null && pred?.daysUntilFull !== void 0) {
+              alertMetrics.days_until_full = pred.daysUntilFull;
+            }
+          } catch (err) {
+            console.error("[alerts] Error computing days_until_full:", err.message);
+          }
         }
         const fired = alertManager.checkAlerts(alertMetrics);
         if (fired.length > 0 && clients.size > 0) {
@@ -2053,8 +2702,7 @@ async function startServer(opts) {
         console.error("[alerts] Error checking alerts:", err.message);
       }
     }
-    return snapshot;
-  };
+  });
   const bindAddr = opts.bind || "127.0.0.1";
   server.listen(opts.port, bindAddr, async () => {
     console.log(`
@@ -2073,9 +2721,10 @@ async function startServer(opts) {
     console.log("\n  Shutting down gracefully...");
     collector.stop();
     schemaTracker.stop();
+    queryStatsStore.stop();
     wss.close();
     server.close();
-    store.close();
+    metricsDb.close();
     schemaDb.close();
     alertsDb.close();
     await pool.end();
@@ -2106,6 +2755,8 @@ var { values, positionals } = parseArgs({
     auth: { type: "string" },
     token: { type: "string" },
     webhook: { type: "string" },
+    "slack-webhook": { type: "string" },
+    "discord-webhook": { type: "string" },
     "no-open": { type: "boolean", default: false },
     json: { type: "boolean", default: false },
     host: { type: "string" },
@@ -2117,6 +2768,7 @@ var { values, positionals } = parseArgs({
     interval: { type: "string", short: "i" },
     "retention-days": { type: "string" },
     "snapshot-interval": { type: "string" },
+    "query-stats-interval": { type: "string" },
     "long-query-threshold": { type: "string" },
     help: { type: "boolean", short: "h" },
     version: { type: "boolean", short: "v" },
@@ -2150,6 +2802,8 @@ Options:
   --auth <user:pass>     Basic auth credentials (user:password)
   --token <token>        Bearer token for authentication
   --webhook <url>        Webhook URL for alert notifications
+  --slack-webhook <url>  Slack webhook URL (convenience alias)
+  --discord-webhook <url> Discord webhook URL (convenience alias)
   --no-open              Don't auto-open browser (default: opens)
   --json                 Dump health check as JSON and exit
   --host <host>          PostgreSQL host
@@ -2161,6 +2815,7 @@ Options:
   -i, --interval <sec>   Collection interval in seconds (default: 30)
   --retention-days <N>   Metrics retention in days (default: 7)
   --snapshot-interval <h> Schema snapshot interval in hours (default: 6)
+  --query-stats-interval <min> Query stats snapshot interval in minutes (default: 5)
   --long-query-threshold <min> Long query threshold in minutes (default: 5)
   --threshold <score>    Health score threshold for check command (default: 70)
   -f, --format <fmt>     Output format: text|json (default: text)
@@ -2198,7 +2853,8 @@ if (subcommand === "check") {
   const { getAdvisorReport: getAdvisorReport2 } = await Promise.resolve().then(() => (init_advisor(), advisor_exports));
   const pool = new Pool2({ connectionString });
   try {
-    const report = await getAdvisorReport2(pool);
+    const lqt = parseInt(values["long-query-threshold"] || process.env.PG_DASH_LONG_QUERY_THRESHOLD || "5", 10);
+    const report = await getAdvisorReport2(pool, lqt);
     if (format === "json") {
       console.log(JSON.stringify(report, null, 2));
     } else {
@@ -2259,10 +2915,11 @@ if (subcommand === "check") {
   const interval = values.interval ? parseInt(values.interval, 10) : void 0;
   const retentionDays = parseInt(values["retention-days"] || process.env.PG_DASH_RETENTION_DAYS || "7", 10);
   const snapshotInterval = parseInt(values["snapshot-interval"] || process.env.PG_DASH_SNAPSHOT_INTERVAL || "6", 10);
+  const queryStatsInterval = parseInt(values["query-stats-interval"] || process.env.PG_DASH_QUERY_STATS_INTERVAL || "5", 10);
   const longQueryThreshold = parseInt(values["long-query-threshold"] || process.env.PG_DASH_LONG_QUERY_THRESHOLD || "5", 10);
   const auth = values.auth || void 0;
   const token = values.token || void 0;
-  const webhook = values.webhook || void 0;
+  const webhook = values["slack-webhook"] || values["discord-webhook"] || values.webhook || void 0;
   if (bind === "0.0.0.0" && !auth && !token) {
     console.warn("\n  \u26A0\uFE0F  WARNING: Dashboard is exposed without authentication. Use --auth or --token.\n");
   }
@@ -2276,6 +2933,7 @@ if (subcommand === "check") {
     interval,
     retentionDays,
     snapshotInterval,
+    queryStatsInterval,
     longQueryThreshold,
     auth,
     token,