@indiekitai/pg-dash 0.3.0 → 0.3.2

package/dist/mcp.js

@@ -13,7 +13,7 @@ async function getOverview(pool2) {
   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"
@@ -197,17 +197,28 @@ async function getActivity(pool2) {
 }
 
 // src/server/advisor.ts
-var SEVERITY_WEIGHT = { critical: 20, warning: 8, info: 3 };
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
+var SEVERITY_WEIGHT = { critical: 15, warning: 5, info: 1 };
+var MAX_DEDUCTION = { critical: 60, warning: 30, info: 10 };
 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)));
 }
@@ -231,7 +242,10 @@ function computeBreakdown(issues) {
 async function getAdvisorReport(pool2, longQueryThreshold2 = 5) {
   const client = await pool2.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,
@@ -256,6 +270,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(`
@@ -284,6 +299,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(`
@@ -309,6 +325,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(`
@@ -338,6 +355,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'");
@@ -366,6 +384,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(`
@@ -391,6 +410,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(`
@@ -419,6 +439,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(`
@@ -454,6 +475,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(`
@@ -462,9 +484,9 @@ SHOW shared_buffers;`,
           extract(epoch from now() - state_change)::int AS idle_seconds
         FROM pg_stat_activity
         WHERE state IN ('idle', 'idle in transaction')
-          AND now() - state_change > interval '${longQueryThreshold2} minutes'
+          AND now() - state_change > $1 * interval '1 minute'
           AND pid != pg_backend_pid()
-      `);
+      `, [longQueryThreshold2]);
       for (const row of r.rows) {
         const isIdleTx = row.state === "idle in transaction";
         issues.push({
@@ -480,6 +502,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(`
@@ -505,6 +528,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(`
@@ -531,6 +555,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(`
@@ -556,6 +581,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(`
@@ -586,6 +612,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(`
@@ -621,6 +648,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(`
@@ -644,13 +672,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) {
@@ -669,6 +699,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'`);
@@ -687,6 +718,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'`);
@@ -710,6 +742,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'`);
@@ -729,6 +762,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(`
@@ -754,6 +788,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'`);
@@ -775,6 +810,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(`
@@ -798,18 +834,44 @@ 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();
   }
 }
+var _ignoredDb = null;
+function getIgnoredDb() {
+  if (_ignoredDb) return _ignoredDb;
+  const dataDir2 = process.env.PG_DASH_DATA_DIR || path.join(os.homedir(), ".pg-dash");
+  fs.mkdirSync(dataDir2, { recursive: true });
+  const dbPath = path.join(dataDir2, "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 isSafeFix(sql) {
   const trimmed = sql.trim();
   if (!trimmed) return false;
@@ -833,10 +895,10 @@ function isSafeFix(sql) {
 }
 
 // src/mcp.ts
-import Database from "better-sqlite3";
-import path from "path";
-import os from "os";
-import fs, { readFileSync } from "fs";
+import Database2 from "better-sqlite3";
+import path2 from "path";
+import os2 from "os";
+import fs2, { readFileSync } from "fs";
 var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 var connString = process.argv[2] || process.env.PG_DASH_CONNECTION_STRING;
 if (!connString) {
@@ -846,19 +908,19 @@ if (!connString) {
 }
 var pool = new Pool({ connectionString: connString });
 var longQueryThreshold = parseInt(process.env.PG_DASH_LONG_QUERY_THRESHOLD || "5", 10);
-var dataDir = process.env.PG_DASH_DATA_DIR || path.join(os.homedir(), ".pg-dash");
-fs.mkdirSync(dataDir, { recursive: true });
+var dataDir = process.env.PG_DASH_DATA_DIR || path2.join(os2.homedir(), ".pg-dash");
+fs2.mkdirSync(dataDir, { recursive: true });
 var schemaDb = null;
 var alertsDb = null;
 try {
-  const schemaPath = path.join(dataDir, "schema.db");
-  if (fs.existsSync(schemaPath)) schemaDb = new Database(schemaPath, { readonly: true });
+  const schemaPath = path2.join(dataDir, "schema.db");
+  if (fs2.existsSync(schemaPath)) schemaDb = new Database2(schemaPath, { readonly: true });
 } catch (err) {
   console.error("[mcp] Error:", err.message);
 }
 try {
-  const alertsPath = path.join(dataDir, "alerts.db");
-  if (fs.existsSync(alertsPath)) alertsDb = new Database(alertsPath, { readonly: true });
+  const alertsPath = path2.join(dataDir, "alerts.db");
+  if (fs2.existsSync(alertsPath)) alertsDb = new Database2(alertsPath, { readonly: true });
 } catch (err) {
   console.error("[mcp] Error:", err.message);
 }