@indiekitai/pg-dash 0.3.1 → 0.3.2

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,51 @@ SELECT pg_reload_conf();`,
       }
     } catch (err) {
       console.error("[advisor] Error checking trust auth:", err.message);
+      skipped.push("trust auth: " + err.message);
     }
-    const score = computeAdvisorScore(issues);
+    const ignoredIds = getIgnoredIssues();
+    const ignoredSet = new Set(ignoredIds);
+    const activeIssues = issues.filter((i) => !ignoredSet.has(i.id));
+    const ignoredCount = issues.length - activeIssues.length;
+    const score = computeAdvisorScore(activeIssues);
     return {
       score,
       grade: gradeFromScore(score),
-      issues,
-      breakdown: computeBreakdown(issues)
+      issues: activeIssues,
+      breakdown: computeBreakdown(activeIssues),
+      skipped,
+      ignoredCount
     };
   } 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 +721,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 +736,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 +748,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 +854,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");
@@ -1831,6 +1904,33 @@ 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.post("/api/fix", async (c) => {
     try {
       const body = await c.req.json();
@@ -2411,10 +2511,10 @@ function registerQueryStatsRoutes(app, store) {
 }
 
 // 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 +2542,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");
@@ -2516,7 +2616,7 @@ async function startServer(opts) {
   registerExplainRoutes(app, pool);
   registerDiskRoutes(app, pool, store);
   registerQueryStatsRoutes(app, queryStatsStore);
-  const uiPath = path2.resolve(__dirname, "ui");
+  const uiPath = path3.resolve(__dirname, "ui");
   const MIME_TYPES = {
     ".html": "text/html",
     ".js": "application/javascript",
@@ -2531,15 +2631,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);
@@ -2738,8 +2838,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 +2878,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");
@@ -2884,14 +2984,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) {