@indiekitai/pg-dash 0.2.0 → 0.3.0

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,7 +281,7 @@ 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 > interval '${longQueryThreshold} minutes'
           AND pid != pg_backend_pid()
       `);
       for (const row of r.rows) {
@@ -777,253 +777,9 @@ 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 [];
-    }
-    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/index.ts
 init_advisor();
 
-// 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);
-    }
-    return {
-      ...tableInfo.rows[0],
-      columns: columns.rows,
-      indexes: indexes.rows,
-      constraints: constraints.rows,
-      foreignKeys: foreignKeys.rows,
-      sampleData
-    };
-  } finally {
-    client.release();
-  }
-}
-async function getSchemaIndexes(pool) {
-  const client = await pool.connect();
-  try {
-    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();
-  }
-}
-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();
-  }
-}
-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();
-  }
-}
-
 // src/server/timeseries.ts
 import Database from "better-sqlite3";
 import path from "path";
@@ -1035,11 +791,15 @@ 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);
+  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);
+    }
     this.retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
@@ -1105,6 +865,7 @@ var Collector = class {
     this.intervalMs = intervalMs;
   }
   timer = null;
+  pruneTimer = null;
   prev = null;
   lastSnapshot = {};
   start() {
@@ -1112,13 +873,17 @@ var Collector = class {
     this.timer = setInterval(() => {
       this.collect().catch((err) => console.error("[collector] Collection failed:", err));
     }, this.intervalMs);
-    setInterval(() => this.store.prune(), 60 * 60 * 1e3);
+    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 };
@@ -1177,6 +942,17 @@ var Collector = class {
           }
           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() 
@@ -1191,21 +967,231 @@ var Collector = class {
         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);
+      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/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);
     }
-    this.lastSnapshot = snapshot;
-    return snapshot;
+    return {
+      ...tableInfo.rows[0],
+      columns: columns.rows,
+      indexes: indexes.rows,
+      constraints: constraints.rows,
+      foreignKeys: foreignKeys.rows,
+      sampleData
+    };
+  } finally {
+    client.release();
   }
-};
+}
+async function getSchemaIndexes(pool) {
+  const client = await pool.connect();
+  try {
+    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();
+  }
+}
+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();
+  }
+}
+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();
+  }
+}
 
 // src/server/schema-diff.ts
 function diffSnapshots(oldSnap, newSnap) {
@@ -1426,6 +1412,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 +1506,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 +1637,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,84 +1694,8 @@ 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));
-var RANGE_MAP = {
-  "5m": 5 * 60 * 1e3,
-  "15m": 15 * 60 * 1e3,
-  "1h": 60 * 60 * 1e3,
-  "6h": 6 * 60 * 60 * 1e3,
-  "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) {
-    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));
-    } 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);
-    });
-  }
+// src/server/routes/overview.ts
+function registerOverviewRoutes(app, pool) {
   app.get("/api/overview", async (c) => {
     try {
       return c.json(await getOverview(pool));
@@ -1684,6 +1717,18 @@ async function startServer(opts) {
       return c.json({ error: err.message }, 500);
     }
   });
+}
+
+// src/server/routes/metrics.ts
+var RANGE_MAP = {
+  "5m": 5 * 60 * 1e3,
+  "15m": 15 * 60 * 1e3,
+  "1h": 60 * 60 * 1e3,
+  "6h": 6 * 60 * 60 * 1e3,
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3
+};
+function registerMetricsRoutes(app, store, collector) {
   app.get("/api/metrics", (c) => {
     try {
       const metric = c.req.query("metric");
@@ -1705,6 +1750,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 +1816,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 +1847,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 +1939,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 +1980,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 +2006,512 @@ 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);
+      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 +2580,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
   });
@@ -2012,7 +2637,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 +2648,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 +2659,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) {
@@ -2073,9 +2720,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 +2754,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 +2767,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 +2801,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 +2814,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 +2852,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 +2914,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 +2932,7 @@ if (subcommand === "check") {
     interval,
     retentionDays,
     snapshotInterval,
+    queryStatsInterval,
     longQueryThreshold,
     auth,
     token,