@indiekitai/pg-dash 0.7.0 → 0.8.0

package/dist/mcp.js

@@ -347,11 +347,13 @@ CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row
     try {
       const r = await client.query(`
         SELECT schemaname, relname, n_dead_tup, n_live_tup,
-          CASE WHEN n_live_tup > 0 THEN round(n_dead_tup::numeric / n_live_tup * 100, 1) ELSE 0 END AS dead_pct,
+          CASE WHEN (n_live_tup + n_dead_tup) > 0
+            THEN round(n_dead_tup::numeric / (n_live_tup + n_dead_tup) * 100, 1) ELSE 0 END AS dead_pct,
           pg_size_pretty(pg_total_relation_size(relid)) AS size
         FROM pg_stat_user_tables
-        WHERE n_live_tup > 1000 AND n_dead_tup::float / GREATEST(n_live_tup, 1) > 0.1
-        ORDER BY n_dead_tup DESC LIMIT 10
+        WHERE (n_live_tup + n_dead_tup) > 0
+          AND n_dead_tup::float / GREATEST(n_live_tup + n_dead_tup, 1) > 0.1
+        ORDER BY n_dead_tup::float / GREATEST(n_live_tup + n_dead_tup, 1) DESC LIMIT 20
       `);
       for (const row of r.rows) {
         const pct = parseFloat(row.dead_pct);
@@ -360,7 +362,7 @@ CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row
           severity: pct > 30 ? "critical" : "warning",
           category: "performance",
           title: `Table bloat on ${row.relname} (${row.dead_pct}% dead)`,
-          description: `${row.schemaname}.${row.relname} has ${Number(row.n_dead_tup).toLocaleString()} dead tuples (${row.dead_pct}% of ${Number(row.n_live_tup).toLocaleString()} live rows). Size: ${row.size}.`,
+          description: `${row.schemaname}.${row.relname} has ${Number(row.n_dead_tup).toLocaleString()} dead tuples (${row.dead_pct}% of ${(Number(row.n_live_tup) + Number(row.n_dead_tup)).toLocaleString()} total rows). Size: ${row.size}.`,
           fix: `VACUUM FULL ${row.schemaname}.${row.relname};`,
           impact: "Dead tuples waste storage and degrade scan performance.",
           effort: pct > 30 ? "moderate" : "quick"
@@ -424,6 +426,18 @@ SHOW shared_buffers;`,
             effort: "moderate"
           });
         }
+      } else {
+        issues.push({
+          id: `perf-no-pg-stat-statements`,
+          severity: "warning",
+          category: "performance",
+          title: `pg_stat_statements extension not installed`,
+          description: `The pg_stat_statements extension is not installed. Without it, slow query detection, query regression analysis, and query performance trending are all unavailable.`,
+          fix: `CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
+-- Also add to shared_preload_libraries in postgresql.conf and restart`,
+          impact: "No visibility into slow queries, query regressions, or performance trends. You are flying blind on query performance.",
+          effort: "moderate"
+        });
       }
     } catch (err) {
       console.error("[advisor] Error checking slow queries:", err.message);
@@ -595,8 +609,8 @@ SHOW shared_buffers;`,
         FROM pg_stat_user_indexes
         WHERE idx_scan = 0
           AND indexrelname NOT LIKE '%_pkey'
-          AND pg_relation_size(indexrelid) > 1048576
-        ORDER BY pg_relation_size(indexrelid) DESC LIMIT 10
+          AND pg_relation_size(indexrelid) > 8192
+        ORDER BY pg_relation_size(indexrelid) DESC LIMIT 20
       `);
       for (const row of r.rows) {
         issues.push({
@@ -777,6 +791,35 @@ SELECT pg_reload_conf();`,
       console.error("[advisor] Error checking autovacuum:", err.message);
       skipped.push("autovacuum: " + err.message);
     }
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname, n_live_tup, n_dead_tup,
+          last_autovacuum, last_vacuum
+        FROM pg_stat_user_tables
+        WHERE n_live_tup < 50
+          AND n_dead_tup > 0
+          AND last_autovacuum IS NULL
+          AND last_vacuum IS NULL
+      `);
+      if (r.rows.length >= 5) {
+        const tables = r.rows.map((row) => row.relname);
+        const totalDead = r.rows.reduce((sum, row) => sum + parseInt(row.n_dead_tup, 10), 0);
+        issues.push({
+          id: `maint-autovacuum-small-tables`,
+          severity: "warning",
+          category: "maintenance",
+          title: `${r.rows.length} small tables never autovacuumed (default threshold=50 too high)`,
+          description: `${r.rows.length} tables with fewer than 50 live rows have never been autovacuumed because the default autovacuum_vacuum_threshold (50) exceeds their row count. Total dead tuples: ${totalDead}. Tables: ${tables.slice(0, 10).join(", ")}${tables.length > 10 ? `, ... and ${tables.length - 10} more` : ""}.`,
+          fix: `-- Lower per-table threshold for small tables:
+${tables.slice(0, 5).map((t) => `ALTER TABLE ${t} SET (autovacuum_vacuum_threshold = 5, autovacuum_vacuum_scale_factor = 0.1);`).join("\n")}`,
+          impact: "Dead tuples accumulate on small tables indefinitely, causing bloat.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking autovacuum small tables:", err.message);
+      skipped.push("autovacuum small tables: " + err.message);
+    }
     try {
       const sbRes = await client.query(`SELECT setting, unit FROM pg_settings WHERE name = 'shared_buffers'`);
       const memRes = await client.query(`
@@ -952,12 +995,7 @@ function getIgnoredIssues() {
     return [];
   }
 }
-function isSafeFix(sql) {
-  const trimmed = sql.trim();
-  if (!trimmed) return false;
-  const statements = trimmed.replace(/;\s*$/, "").split(";").map((s) => s.trim()).filter(Boolean);
-  if (statements.length !== 1) return false;
-  const upper = statements[0].toUpperCase();
+function isSafeSingleStatement(upper) {
   if (upper.startsWith("EXPLAIN ANALYZE")) {
     const afterExplain = upper.replace(/^EXPLAIN\s+ANALYZE\s+/, "").trimStart();
     return afterExplain.startsWith("SELECT");
@@ -971,8 +1009,18 @@ function isSafeFix(sql) {
     "SELECT PG_TERMINATE_BACKEND(",
     "SELECT PG_CANCEL_BACKEND("
   ];
+  if (upper.startsWith("ALTER TABLE")) {
+    return /^ALTER TABLE\s+\S+\s+SET\s*\(/i.test(upper);
+  }
   return ALLOWED_PREFIXES.some((p) => upper.startsWith(p));
 }
+function isSafeFix(sql) {
+  const trimmed = sql.trim();
+  if (!trimmed) return false;
+  const statements = trimmed.replace(/;\s*$/, "").split(";").map((s) => s.trim()).filter(Boolean);
+  if (statements.length === 0) return false;
+  return statements.every((stmt) => isSafeSingleStatement(stmt.toUpperCase()));
+}
 
 // src/server/queries/slow-queries.ts
 async function getSlowQueries(pool2) {
@@ -2986,14 +3034,25 @@ server.tool("pg_dash_schema_changes", "Get recent schema changes", {}, async ()
     return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
   }
 });
-server.tool("pg_dash_fix", "Execute a safe fix (VACUUM, ANALYZE, REINDEX, etc.)", { sql: z.string().describe("SQL to execute (must be a safe operation)") }, async ({ sql }) => {
+server.tool("pg_dash_fix", "Execute safe fix(es) \u2014 supports batch: multiple VACUUM/ANALYZE/REINDEX statements separated by semicolons", { sql: z.string().describe("SQL to execute (must be safe operations; multiple statements separated by ; are supported)") }, async ({ sql }) => {
   try {
-    if (!isSafeFix(sql)) return { content: [{ type: "text", text: "Operation not allowed. Only VACUUM, ANALYZE, REINDEX, CREATE/DROP INDEX CONCURRENTLY, pg_terminate_backend, pg_cancel_backend, and EXPLAIN ANALYZE are permitted." }], isError: true };
+    if (!isSafeFix(sql)) return { content: [{ type: "text", text: "Operation not allowed. Only VACUUM, ANALYZE, REINDEX, CREATE/DROP INDEX CONCURRENTLY, ALTER TABLE SET, pg_terminate_backend, pg_cancel_backend, and EXPLAIN ANALYZE are permitted." }], isError: true };
     const client = await pool.connect();
     try {
+      const statements = sql.trim().replace(/;\s*$/, "").split(";").map((s) => s.trim()).filter(Boolean);
       const start = Date.now();
-      const result = await client.query(sql);
-      return { content: [{ type: "text", text: JSON.stringify({ ok: true, duration: Date.now() - start, rowCount: result.rowCount, rows: result.rows || [] }, null, 2) }] };
+      const results = [];
+      for (const stmt of statements) {
+        try {
+          await client.query(stmt);
+          results.push({ sql: stmt, ok: true });
+        } catch (err) {
+          results.push({ sql: stmt, ok: false, error: err.message });
+        }
+      }
+      const succeeded = results.filter((r) => r.ok).length;
+      const failed = results.filter((r) => !r.ok).length;
+      return { content: [{ type: "text", text: JSON.stringify({ ok: failed === 0, duration: Date.now() - start, total: statements.length, succeeded, failed, results }, null, 2) }] };
     } finally {
       client.release();
     }
@@ -3010,15 +3069,15 @@ server.tool("pg_dash_alerts", "Get alert history", {}, async () => {
     return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
   }
 });
-server.tool("pg_dash_explain", "Run EXPLAIN ANALYZE on a SELECT query (read-only, wrapped in BEGIN/ROLLBACK)", { query: z.string().describe("SELECT query to explain") }, async ({ query }) => {
+server.tool("pg_dash_explain", "Run EXPLAIN ANALYZE on a SELECT query (read-only, wrapped in BEGIN/ROLLBACK)", { sql: z.string().describe("SELECT query to explain") }, async ({ sql }) => {
   try {
-    if (!/^\s*SELECT\b/i.test(query)) return { content: [{ type: "text", text: "Error: Only SELECT queries are allowed" }], isError: true };
+    if (!/^\s*SELECT\b/i.test(sql)) return { content: [{ type: "text", text: "Error: Only SELECT queries are allowed" }], isError: true };
     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}`);
+        const r = await client.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${sql}`);
         await client.query("ROLLBACK");
         await client.query("RESET statement_timeout");
         return { content: [{ type: "text", text: JSON.stringify(r.rows[0]["QUERY PLAN"], null, 2) }] };