@indiekitai/pg-dash 0.3.1 → 0.3.3

package/dist/cli.js

@@ -14,19 +14,32 @@ var advisor_exports = {};
 __export(advisor_exports, {
   computeAdvisorScore: () => computeAdvisorScore,
   getAdvisorReport: () => getAdvisorReport,
+  getIgnoredIssues: () => getIgnoredIssues,
   gradeFromScore: () => gradeFromScore,
-  isSafeFix: () => isSafeFix
+  ignoreIssue: () => ignoreIssue,
+  isSafeFix: () => isSafeFix,
+  unignoreIssue: () => unignoreIssue
 });
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
 function computeAdvisorScore(issues) {
   let score = 100;
+  const deductions = { critical: 0, warning: 0, info: 0 };
   const counts = { critical: 0, warning: 0, info: 0 };
   for (const issue of issues) {
     counts[issue.severity]++;
     const n = counts[issue.severity];
     const weight = SEVERITY_WEIGHT[issue.severity];
-    if (n <= 5) score -= weight;
-    else if (n <= 15) score -= weight * 0.5;
-    else score -= weight * 0.25;
+    let penalty;
+    if (n <= 3) penalty = weight;
+    else if (n <= 10) penalty = weight * 0.5;
+    else penalty = weight * 0.25;
+    deductions[issue.severity] += penalty;
+  }
+  for (const sev of ["critical", "warning", "info"]) {
+    score -= Math.min(deductions[sev], MAX_DEDUCTION[sev]);
   }
   return Math.max(0, Math.min(100, Math.round(score)));
 }
@@ -50,7 +63,10 @@ function computeBreakdown(issues) {
 async function getAdvisorReport(pool, longQueryThreshold = 5) {
   const client = await pool.connect();
   const issues = [];
+  const skipped = [];
   try {
+    const versionResult = await client.query("SHOW server_version_num");
+    const pgVersion = parseInt(versionResult.rows[0].server_version_num);
     try {
       const r = await client.query(`
         SELECT schemaname, relname, seq_scan, seq_tup_read, n_live_tup,
@@ -75,6 +91,7 @@ CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row
       }
     } catch (err) {
       console.error("[advisor] Error checking seq scans:", err.message);
+      skipped.push("seq scans: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -103,6 +120,7 @@ CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row
       }
     } catch (err) {
       console.error("[advisor] Error checking bloated indexes:", err.message);
+      skipped.push("bloated indexes: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -128,6 +146,7 @@ CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row
       }
     } catch (err) {
       console.error("[advisor] Error checking table bloat:", err.message);
+      skipped.push("table bloat: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -157,6 +176,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking cache efficiency:", err.message);
+      skipped.push("cache efficiency: " + err.message);
     }
     try {
       const extCheck = await client.query("SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'");
@@ -185,6 +205,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking slow queries:", err.message);
+      skipped.push("slow queries: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -210,6 +231,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking vacuum overdue:", err.message);
+      skipped.push("vacuum overdue: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -238,6 +260,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking analyze overdue:", err.message);
+      skipped.push("analyze overdue: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -273,6 +296,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking xid wraparound:", err.message);
+      skipped.push("xid wraparound: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -299,6 +323,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking idle connections:", err.message);
+      skipped.push("idle connections: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -324,6 +349,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking missing primary keys:", err.message);
+      skipped.push("missing primary keys: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -350,6 +376,7 @@ SHOW shared_buffers;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking unused indexes:", err.message);
+      skipped.push("unused indexes: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -375,6 +402,7 @@ DROP INDEX CONCURRENTLY ${row.indexes.slice(1).join(";\nDROP INDEX CONCURRENTLY
       }
     } catch (err) {
       console.error("[advisor] Error checking duplicate indexes:", err.message);
+      skipped.push("duplicate indexes: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -405,6 +433,7 @@ DROP INDEX CONCURRENTLY ${row.indexes.slice(1).join(";\nDROP INDEX CONCURRENTLY
       }
     } catch (err) {
       console.error("[advisor] Error checking missing FK indexes:", err.message);
+      skipped.push("missing FK indexes: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -440,6 +469,7 @@ DROP INDEX CONCURRENTLY ${row.indexes.slice(1).join(";\nDROP INDEX CONCURRENTLY
       }
     } catch (err) {
       console.error("[advisor] Error checking locks:", err.message);
+      skipped.push("locks: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -463,13 +493,15 @@ SELECT * FROM pg_stat_replication;`,
       }
     } catch (err) {
       console.error("[advisor] Error checking replication lag:", err.message);
+      skipped.push("replication lag: " + err.message);
     }
     try {
+      const checkpointView = pgVersion >= 17e4 ? "pg_stat_checkpointer" : "pg_stat_bgwriter";
       const r = await client.query(`
         SELECT checkpoints_req, checkpoints_timed,
           CASE WHEN (checkpoints_req + checkpoints_timed) = 0 THEN 0
             ELSE round(checkpoints_req::numeric / (checkpoints_req + checkpoints_timed) * 100, 1) END AS req_pct
-        FROM pg_stat_bgwriter
+        FROM ${checkpointView}
       `);
       const reqPct = parseFloat(r.rows[0]?.req_pct ?? "0");
       if (reqPct > 50) {
@@ -488,6 +520,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking checkpoint frequency:", err.message);
+      skipped.push("checkpoint frequency: " + err.message);
     }
     try {
       const r = await client.query(`SELECT setting FROM pg_settings WHERE name = 'autovacuum'`);
@@ -506,6 +539,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking autovacuum:", err.message);
+      skipped.push("autovacuum: " + err.message);
     }
     try {
       const sbRes = await client.query(`SELECT setting, unit FROM pg_settings WHERE name = 'shared_buffers'`);
@@ -529,6 +563,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking shared_buffers:", err.message);
+      skipped.push("shared_buffers: " + err.message);
     }
     try {
       const r = await client.query(`SELECT setting, unit FROM pg_settings WHERE name = 'work_mem'`);
@@ -548,6 +583,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking work_mem:", err.message);
+      skipped.push("work_mem: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -573,6 +609,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking superuser connections:", err.message);
+      skipped.push("superuser connections: " + err.message);
     }
     try {
       const r = await client.query(`SELECT setting FROM pg_settings WHERE name = 'ssl'`);
@@ -594,6 +631,7 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking SSL check:", err.message);
+      skipped.push("SSL check: " + err.message);
     }
     try {
       const r = await client.query(`
@@ -617,18 +655,74 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking trust auth:", err.message);
+      skipped.push("trust auth: " + err.message);
+    }
+    const ignoredIds = getIgnoredIssues();
+    const ignoredSet = new Set(ignoredIds);
+    const activeIssues = issues.filter((i) => !ignoredSet.has(i.id));
+    const ignoredCount = issues.length - activeIssues.length;
+    const batchFixes = [];
+    const groups = /* @__PURE__ */ new Map();
+    for (const issue of activeIssues) {
+      const prefix = issue.id.replace(/-[^-]+$/, "");
+      if (!groups.has(prefix)) groups.set(prefix, []);
+      groups.get(prefix).push(issue);
+    }
+    const BATCH_TITLES = {
+      "schema-fk-no-idx": "Create all missing FK indexes",
+      "schema-unused-idx": "Drop all unused indexes",
+      "schema-no-pk": "Fix all tables missing primary keys",
+      "maint-vacuum": "VACUUM all overdue tables",
+      "maint-analyze": "ANALYZE all tables missing statistics",
+      "perf-bloated-idx": "REINDEX all bloated indexes",
+      "perf-bloat": "VACUUM FULL all bloated tables"
+    };
+    for (const [prefix, group] of groups) {
+      if (group.length <= 1) continue;
+      const title = BATCH_TITLES[prefix] || `Fix all ${group.length} ${prefix} issues`;
+      const sql = group.map((i) => i.fix.split("\n").filter((l) => !l.trim().startsWith("--")).join("\n").trim()).filter(Boolean).join(";\n") + ";";
+      batchFixes.push({ type: prefix, title: `${title} (${group.length})`, count: group.length, sql });
     }
-    const score = computeAdvisorScore(issues);
+    const score = computeAdvisorScore(activeIssues);
     return {
       score,
       grade: gradeFromScore(score),
-      issues,
-      breakdown: computeBreakdown(issues)
+      issues: activeIssues,
+      breakdown: computeBreakdown(activeIssues),
+      skipped,
+      ignoredCount,
+      batchFixes
     };
   } finally {
     client.release();
   }
 }
+function getIgnoredDb() {
+  if (_ignoredDb) return _ignoredDb;
+  const dataDir = process.env.PG_DASH_DATA_DIR || path.join(os.homedir(), ".pg-dash");
+  fs.mkdirSync(dataDir, { recursive: true });
+  const dbPath = path.join(dataDir, "alerts.db");
+  _ignoredDb = new Database(dbPath);
+  _ignoredDb.pragma("journal_mode = WAL");
+  _ignoredDb.exec("CREATE TABLE IF NOT EXISTS ignored_issues (issue_id TEXT PRIMARY KEY, ignored_at INTEGER)");
+  return _ignoredDb;
+}
+function getIgnoredIssues() {
+  try {
+    const db = getIgnoredDb();
+    return db.prepare("SELECT issue_id FROM ignored_issues").all().map((r) => r.issue_id);
+  } catch {
+    return [];
+  }
+}
+function ignoreIssue(issueId) {
+  const db = getIgnoredDb();
+  db.prepare("INSERT OR REPLACE INTO ignored_issues (issue_id, ignored_at) VALUES (?, ?)").run(issueId, Date.now());
+}
+function unignoreIssue(issueId) {
+  const db = getIgnoredDb();
+  db.prepare("DELETE FROM ignored_issues WHERE issue_id = ?").run(issueId);
+}
 function isSafeFix(sql) {
   const trimmed = sql.trim();
   if (!trimmed) return false;
@@ -650,11 +744,13 @@ function isSafeFix(sql) {
   ];
   return ALLOWED_PREFIXES.some((p) => upper.startsWith(p));
 }
-var SEVERITY_WEIGHT;
+var SEVERITY_WEIGHT, MAX_DEDUCTION, _ignoredDb;
 var init_advisor = __esm({
   "src/server/advisor.ts"() {
     "use strict";
-    SEVERITY_WEIGHT = { critical: 20, warning: 8, info: 3 };
+    SEVERITY_WEIGHT = { critical: 15, warning: 5, info: 1 };
+    MAX_DEDUCTION = { critical: 60, warning: 30, info: 10 };
+    _ignoredDb = null;
   }
 });
 
@@ -663,9 +759,9 @@ import { parseArgs } from "util";
 
 // src/server/index.ts
 import { Hono } from "hono";
-import path2 from "path";
-import fs2 from "fs";
-import os2 from "os";
+import path3 from "path";
+import fs3 from "fs";
+import os3 from "os";
 import { fileURLToPath } from "url";
 import { Pool } from "pg";
 
@@ -675,7 +771,7 @@ async function getOverview(pool) {
   try {
     const version = await client.query("SHOW server_version");
     const uptime = await client.query(
-      "SELECT now() - pg_postmaster_start_time() AS uptime"
+      `SELECT to_char(now() - pg_postmaster_start_time(), 'DD "d" HH24 "h" MI "m"') AS uptime`
     );
     const dbSize = await client.query(
       "SELECT pg_size_pretty(pg_database_size(current_database())) AS size"
@@ -781,24 +877,24 @@ async function getActivity(pool) {
 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");
+import Database2 from "better-sqlite3";
+import path2 from "path";
+import os2 from "os";
+import fs2 from "fs";
+var DEFAULT_DIR = path2.join(os2.homedir(), ".pg-dash");
 var DEFAULT_RETENTION_DAYS = 7;
 var TimeseriesStore = class {
   db;
   insertStmt;
   retentionMs;
   constructor(dbOrDir, retentionDays = DEFAULT_RETENTION_DAYS) {
-    if (dbOrDir instanceof Database) {
+    if (dbOrDir instanceof Database2) {
       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);
+      fs2.mkdirSync(dir, { recursive: true });
+      const dbPath = path2.join(dir, "metrics.db");
+      this.db = new Database2(dbPath);
     }
     this.retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
     this.db.pragma("journal_mode = WAL");
@@ -870,6 +966,7 @@ var Collector = class extends EventEmitter {
   pruneTimer = null;
   prev = null;
   lastSnapshot = {};
+  collectCount = 0;
   start() {
     this.collect().catch((err) => console.error("[collector] Initial collection failed:", err));
     this.timer = setInterval(() => {
@@ -972,6 +1069,28 @@ var Collector = class extends EventEmitter {
       console.error("[collector] Error collecting metrics:", err.message);
       return snapshot;
     }
+    this.collectCount++;
+    if (this.collectCount % 10 === 0) {
+      try {
+        const client = await this.pool.connect();
+        try {
+          const tableRes = await client.query(`
+            SELECT schemaname, relname,
+                   pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as total_size
+            FROM pg_stat_user_tables
+            ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
+            LIMIT 20
+          `);
+          for (const row of tableRes.rows) {
+            this.store.insert(`table_size:${row.schemaname}.${row.relname}`, parseInt(row.total_size), now);
+          }
+        } finally {
+          client.release();
+        }
+      } catch (err) {
+        console.error("[collector] Error collecting table sizes:", err.message);
+      }
+    }
     const points = Object.entries(snapshot).map(([metric, value]) => ({
       timestamp: now,
       metric,
@@ -1823,7 +1942,12 @@ function registerActivityRoutes(app, pool) {
 
 // src/server/routes/advisor.ts
 init_advisor();
-function registerAdvisorRoutes(app, pool, longQueryThreshold) {
+var RANGE_MAP2 = {
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3
+};
+function registerAdvisorRoutes(app, pool, longQueryThreshold, store) {
   app.get("/api/advisor", async (c) => {
     try {
       return c.json(await getAdvisorReport(pool, longQueryThreshold));
@@ -1831,6 +1955,45 @@ function registerAdvisorRoutes(app, pool, longQueryThreshold) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/advisor/ignored", (c) => {
+    try {
+      return c.json(getIgnoredIssues());
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/api/advisor/ignore", async (c) => {
+    try {
+      const body = await c.req.json();
+      const issueId = body?.issueId;
+      if (!issueId) return c.json({ error: "issueId required" }, 400);
+      ignoreIssue(issueId);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.delete("/api/advisor/ignore/:issueId", (c) => {
+    try {
+      const issueId = c.req.param("issueId");
+      unignoreIssue(issueId);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/api/advisor/history", (c) => {
+    if (!store) return c.json([]);
+    try {
+      const range = c.req.query("range") || "24h";
+      const rangeMs = RANGE_MAP2[range] || RANGE_MAP2["24h"];
+      const now = Date.now();
+      const data = store.query("health_score", now - rangeMs, now);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
   app.post("/api/fix", async (c) => {
     try {
       const body = await c.req.json();
@@ -2114,7 +2277,7 @@ var DiskPredictor = class {
 };
 
 // src/server/routes/disk.ts
-var RANGE_MAP2 = {
+var RANGE_MAP3 = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
   "30d": 30 * 24 * 60 * 60 * 1e3
@@ -2174,10 +2337,22 @@ function registerDiskRoutes(app, pool, store) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/disk/table-history/:table", (c) => {
+    try {
+      const table = c.req.param("table");
+      const range = c.req.query("range") || "24h";
+      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["24h"];
+      const now = Date.now();
+      const data = store.query(`table_size:${table}`, now - rangeMs, now);
+      return c.json(data);
+    } 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 rangeMs = RANGE_MAP3[range] || RANGE_MAP3["24h"];
       const now = Date.now();
       const data = store.query("db_size_bytes", now - rangeMs, now);
       return c.json(data);
@@ -2376,7 +2551,7 @@ var QueryStatsStore = class {
 };
 
 // src/server/routes/query-stats.ts
-var RANGE_MAP3 = {
+var RANGE_MAP4 = {
   "1h": 60 * 60 * 1e3,
   "6h": 6 * 60 * 60 * 1e3,
   "24h": 24 * 60 * 60 * 1e3,
@@ -2388,7 +2563,7 @@ function registerQueryStatsRoutes(app, store) {
       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 rangeMs = RANGE_MAP4[range] || RANGE_MAP4["1h"];
       const now = Date.now();
       const data = store.getTopQueries(now - rangeMs, now, orderBy, limit);
       return c.json(data);
@@ -2400,7 +2575,7 @@ function registerQueryStatsRoutes(app, store) {
     try {
       const queryid = c.req.param("queryid");
       const range = c.req.query("range") || "1h";
-      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["1h"];
+      const rangeMs = RANGE_MAP4[range] || RANGE_MAP4["1h"];
       const now = Date.now();
       const data = store.getTrend(queryid, now - rangeMs, now);
       return c.json(data);
@@ -2410,11 +2585,79 @@ function registerQueryStatsRoutes(app, store) {
   });
 }
 
+// src/server/routes/export.ts
+init_advisor();
+function registerExportRoutes(app, pool, longQueryThreshold) {
+  app.get("/api/export", async (c) => {
+    const format = c.req.query("format") || "json";
+    try {
+      const [overview, advisor] = await Promise.all([
+        getOverview(pool),
+        getAdvisorReport(pool, longQueryThreshold)
+      ]);
+      if (format === "md") {
+        const lines = [];
+        lines.push(`# pg-dash Health Report`);
+        lines.push(`
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+        lines.push(`## Overview
+`);
+        lines.push(`- **PostgreSQL**: ${overview.version}`);
+        lines.push(`- **Database Size**: ${overview.dbSize}`);
+        lines.push(`- **Connections**: ${overview.connections.active} active / ${overview.connections.idle} idle / ${overview.connections.max} max`);
+        lines.push(`
+## Health Score: ${advisor.score}/100 (Grade: ${advisor.grade})
+`);
+        lines.push(`### Category Breakdown
+`);
+        lines.push(`| Category | Grade | Score | Issues |`);
+        lines.push(`|----------|-------|-------|--------|`);
+        for (const [cat, b] of Object.entries(advisor.breakdown)) {
+          lines.push(`| ${cat} | ${b.grade} | ${b.score}/100 | ${b.count} |`);
+        }
+        if (advisor.issues.length > 0) {
+          lines.push(`
+### Issues (${advisor.issues.length})
+`);
+          for (const issue of advisor.issues) {
+            const icon = issue.severity === "critical" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+            lines.push(`#### ${icon} [${issue.severity}] ${issue.title}
+`);
+            lines.push(`${issue.description}
+`);
+            lines.push(`**Impact**: ${issue.impact}
+`);
+            lines.push(`**Fix**:
+\`\`\`sql
+${issue.fix}
+\`\`\`
+`);
+          }
+        } else {
+          lines.push(`
+\u2705 No issues found!
+`);
+        }
+        const md = lines.join("\n");
+        c.header("Content-Type", "text/markdown; charset=utf-8");
+        c.header("Content-Disposition", `attachment; filename="pg-dash-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.md"`);
+        return c.body(md);
+      }
+      const data = { overview, advisor, exportedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      c.header("Content-Disposition", `attachment; filename="pg-dash-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json"`);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
 // src/server/index.ts
-import Database2 from "better-sqlite3";
+import Database3 from "better-sqlite3";
 import { WebSocketServer, WebSocket } from "ws";
 import http from "http";
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 async function startServer(opts) {
   const pool = new Pool({ connectionString: opts.connectionString });
   try {
@@ -2442,25 +2685,25 @@ async function startServer(opts) {
     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);
+  const dataDir = opts.dataDir || path3.join(os3.homedir(), ".pg-dash");
+  fs3.mkdirSync(dataDir, { recursive: true });
+  const metricsDbPath = path3.join(dataDir, "metrics.db");
+  const metricsDb = new Database3(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);
+  const schemaDbPath = path3.join(dataDir, "schema.db");
+  const schemaDb = new Database3(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);
+  const alertsDbPath = path3.join(dataDir, "alerts.db");
+  const alertsDb = new Database3(alertsDbPath);
   alertsDb.pragma("journal_mode = WAL");
   const alertManager = new AlertManager(alertsDb, opts.webhook);
   console.log("  Alert monitoring enabled");
@@ -2510,13 +2753,14 @@ async function startServer(opts) {
   registerOverviewRoutes(app, pool);
   registerMetricsRoutes(app, store, collector);
   registerActivityRoutes(app, pool);
-  registerAdvisorRoutes(app, pool, longQueryThreshold);
+  registerAdvisorRoutes(app, pool, longQueryThreshold, store);
   registerSchemaRoutes(app, pool, schemaTracker);
   registerAlertsRoutes(app, alertManager);
   registerExplainRoutes(app, pool);
   registerDiskRoutes(app, pool, store);
   registerQueryStatsRoutes(app, queryStatsStore);
-  const uiPath = path2.resolve(__dirname, "ui");
+  registerExportRoutes(app, pool, longQueryThreshold);
+  const uiPath = path3.resolve(__dirname, "ui");
   const MIME_TYPES = {
     ".html": "text/html",
     ".js": "application/javascript",
@@ -2531,15 +2775,15 @@ async function startServer(opts) {
   };
   app.get("/*", async (c) => {
     const urlPath = c.req.path === "/" ? "/index.html" : c.req.path;
-    const filePath = path2.join(uiPath, urlPath);
+    const filePath = path3.join(uiPath, urlPath);
     try {
-      const content = await fs2.promises.readFile(filePath);
-      const ext = path2.extname(filePath);
+      const content = await fs3.promises.readFile(filePath);
+      const ext = path3.extname(filePath);
       const contentType = MIME_TYPES[ext] || "application/octet-stream";
       return new Response(content, { headers: { "content-type": contentType } });
     } catch {
       try {
-        const html = await fs2.promises.readFile(path2.join(uiPath, "index.html"));
+        const html = await fs3.promises.readFile(path3.join(uiPath, "index.html"));
         return new Response(html, { headers: { "content-type": "text/html" } });
       } catch (err) {
         console.error("[static] Error reading index.html:", err.message);
@@ -2663,6 +2907,7 @@ async function startServer(opts) {
           try {
             const report = await getAdvisorReport(pool, longQueryThreshold);
             alertMetrics.health_score = report.score;
+            store.insert("health_score", report.score);
           } catch (err) {
             console.error("[alerts] Error checking health score:", err.message);
           }
@@ -2738,8 +2983,8 @@ async function startServer(opts) {
 }
 
 // src/cli.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 process.on("uncaughtException", (err) => {
   console.error("Uncaught exception:", err);
@@ -2778,8 +3023,8 @@ var { values, positionals } = parseArgs({
 });
 if (values.version) {
   try {
-    const __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(fs3.readFileSync(path3.resolve(__dirname2, "../package.json"), "utf-8"));
+    const __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(fs4.readFileSync(path4.resolve(__dirname2, "../package.json"), "utf-8"));
     console.log(`pg-dash v${pkg.version}`);
   } catch {
     console.log("pg-dash v0.1.0");
@@ -2818,7 +3063,7 @@ Options:
   --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)
+  -f, --format <fmt>     Output format: text|json|md (default: text)
   -v, --version          Show version
   -h, --help             Show this help
 
@@ -2857,6 +3102,38 @@ if (subcommand === "check") {
     const report = await getAdvisorReport2(pool, lqt);
     if (format === "json") {
       console.log(JSON.stringify(report, null, 2));
+    } else if (format === "md") {
+      console.log(`# pg-dash Health Report
+`);
+      console.log(`Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+      console.log(`## Health Score: ${report.score}/100 (Grade: ${report.grade})
+`);
+      console.log(`| Category | Grade | Score | Issues |`);
+      console.log(`|----------|-------|-------|--------|`);
+      for (const [cat, b] of Object.entries(report.breakdown)) {
+        console.log(`| ${cat} | ${b.grade} | ${b.score}/100 | ${b.count} |`);
+      }
+      if (report.issues.length > 0) {
+        console.log(`
+### Issues (${report.issues.length})
+`);
+        for (const issue of report.issues) {
+          const icon = issue.severity === "critical" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+          console.log(`#### ${icon} [${issue.severity}] ${issue.title}
+`);
+          console.log(`${issue.description}
+`);
+          console.log(`**Fix**:
+\`\`\`sql
+${issue.fix}
+\`\`\`
+`);
+        }
+      } else {
+        console.log(`
+\u2705 No issues found!`);
+      }
     } else {
       console.log(`
   Health Score: ${report.score}/100 (Grade: ${report.grade})
@@ -2884,14 +3161,14 @@ if (subcommand === "check") {
   }
 } else if (subcommand === "schema-diff") {
   const connectionString = resolveConnectionString(1);
-  const dataDir = values["data-dir"] || path3.join((await import("os")).homedir(), ".pg-dash");
-  const schemaDbPath = path3.join(dataDir, "schema.db");
-  if (!fs3.existsSync(schemaDbPath)) {
+  const dataDir = values["data-dir"] || path4.join((await import("os")).homedir(), ".pg-dash");
+  const schemaDbPath = path4.join(dataDir, "schema.db");
+  if (!fs4.existsSync(schemaDbPath)) {
     console.error("No schema tracking data found. Run pg-dash server first to collect schema snapshots.");
     process.exit(1);
   }
-  const Database3 = (await import("better-sqlite3")).default;
-  const db = new Database3(schemaDbPath, { readonly: true });
+  const Database4 = (await import("better-sqlite3")).default;
+  const db = new Database4(schemaDbPath, { readonly: true });
   const changes = db.prepare("SELECT * FROM schema_changes ORDER BY timestamp DESC LIMIT 50").all();
   db.close();
   if (changes.length === 0) {