@indiekitai/pg-dash 0.3.2 → 0.3.4

package/dist/mcp.js

@@ -840,6 +840,28 @@ SELECT pg_reload_conf();`,
     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(activeIssues);
     return {
       score,
@@ -847,7 +869,8 @@ SELECT pg_reload_conf();`,
       issues: activeIssues,
       breakdown: computeBreakdown(activeIssues),
       skipped,
-      ignoredCount
+      ignoredCount,
+      batchFixes
     };
   } finally {
     client.release();
@@ -894,11 +917,81 @@ function isSafeFix(sql) {
   return ALLOWED_PREFIXES.some((p) => upper.startsWith(p));
 }
 
+// src/server/queries/slow-queries.ts
+async function getSlowQueries(pool2) {
+  const client = await pool2.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/snapshot.ts
+import fs2 from "fs";
+import path2 from "path";
+var SNAPSHOT_FILE = "last-check.json";
+function saveSnapshot(dataDir2, result) {
+  fs2.mkdirSync(dataDir2, { recursive: true });
+  const snapshot = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), result };
+  fs2.writeFileSync(path2.join(dataDir2, SNAPSHOT_FILE), JSON.stringify(snapshot, null, 2));
+}
+function loadSnapshot(dataDir2) {
+  const filePath = path2.join(dataDir2, SNAPSHOT_FILE);
+  if (!fs2.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function diffSnapshots(prev, current) {
+  const prevIds = new Set(prev.issues.map((i) => i.id));
+  const currIds = new Set(current.issues.map((i) => i.id));
+  const newIssues = current.issues.filter((i) => !prevIds.has(i.id));
+  const resolvedIssues = prev.issues.filter((i) => !currIds.has(i.id));
+  const unchanged = current.issues.filter((i) => prevIds.has(i.id));
+  return {
+    scoreDelta: current.score - prev.score,
+    previousScore: prev.score,
+    currentScore: current.score,
+    previousGrade: prev.grade,
+    currentGrade: current.grade,
+    newIssues,
+    resolvedIssues,
+    unchanged
+  };
+}
+
 // src/mcp.ts
 import Database2 from "better-sqlite3";
-import path2 from "path";
+import path3 from "path";
 import os2 from "os";
-import fs2, { readFileSync } from "fs";
+import fs3, { 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) {
@@ -908,19 +1001,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 || path2.join(os2.homedir(), ".pg-dash");
-fs2.mkdirSync(dataDir, { recursive: true });
+var dataDir = process.env.PG_DASH_DATA_DIR || path3.join(os2.homedir(), ".pg-dash");
+fs3.mkdirSync(dataDir, { recursive: true });
 var schemaDb = null;
 var alertsDb = null;
 try {
-  const schemaPath = path2.join(dataDir, "schema.db");
-  if (fs2.existsSync(schemaPath)) schemaDb = new Database2(schemaPath, { readonly: true });
+  const schemaPath = path3.join(dataDir, "schema.db");
+  if (fs3.existsSync(schemaPath)) schemaDb = new Database2(schemaPath, { readonly: true });
 } catch (err) {
   console.error("[mcp] Error:", err.message);
 }
 try {
-  const alertsPath = path2.join(dataDir, "alerts.db");
-  if (fs2.existsSync(alertsPath)) alertsDb = new Database2(alertsPath, { readonly: true });
+  const alertsPath = path3.join(dataDir, "alerts.db");
+  if (fs3.existsSync(alertsPath)) alertsDb = new Database2(alertsPath, { readonly: true });
 } catch (err) {
   console.error("[mcp] Error:", err.message);
 }
@@ -999,6 +1092,153 @@ 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 }) => {
+  try {
+    if (!/^\s*SELECT\b/i.test(query)) 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}`);
+        await client.query("ROLLBACK");
+        await client.query("RESET statement_timeout");
+        return { content: [{ type: "text", text: JSON.stringify(r.rows[0]["QUERY PLAN"], null, 2) }] };
+      } catch (err) {
+        await client.query("ROLLBACK").catch(() => {
+        });
+        await client.query("RESET statement_timeout").catch(() => {
+        });
+        return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+      }
+    } finally {
+      client.release();
+    }
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_batch_fix", "Get batch fix SQL for issues (optionally filtered by category)", { category: z.string().optional().describe("Filter by issue type prefix, e.g. 'schema-missing-fk-index'") }, async ({ category }) => {
+  try {
+    const report = await getAdvisorReport(pool, longQueryThreshold);
+    let fixes = report.batchFixes;
+    if (category) fixes = fixes.filter((f) => f.type.startsWith(category));
+    if (fixes.length === 0) return { content: [{ type: "text", text: "No batch fixes found" + (category ? ` for category '${category}'` : "") }] };
+    const combined = fixes.map((f) => `-- ${f.title}
+${f.sql}`).join("\n\n");
+    return { content: [{ type: "text", text: combined }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_slow_queries", "Get top slow queries from pg_stat_statements", {
+  limit: z.number().optional().default(20).describe("Max queries to return (default 20)"),
+  orderBy: z.enum(["total_time", "mean_time", "calls"]).optional().default("total_time").describe("Sort order")
+}, async ({ limit, orderBy }) => {
+  try {
+    const all = await getSlowQueries(pool);
+    if (all.length === 0) return { content: [{ type: "text", text: "No slow query data available. pg_stat_statements may not be installed." }] };
+    const sorted = [...all].sort((a, b) => b[orderBy] - a[orderBy]);
+    return { content: [{ type: "text", text: JSON.stringify(sorted.slice(0, limit), null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_table_sizes", "Get table sizes with data/index breakdown (top 30)", {}, async () => {
+  try {
+    const client = await pool.connect();
+    try {
+      const r = 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 30
+      `);
+      const tables = r.rows.map((row) => ({
+        schema: row.schemaname,
+        name: row.relname,
+        totalSize: parseInt(row.total_size),
+        tableSize: parseInt(row.table_size),
+        indexSize: parseInt(row.index_size)
+      }));
+      return { content: [{ type: "text", text: JSON.stringify(tables, null, 2) }] };
+    } finally {
+      client.release();
+    }
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_export", "Export full health report", { format: z.enum(["json", "md"]).optional().default("json").describe("Output format: json or md") }, async ({ format }) => {
+  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 | 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}`);
+        }
+      }
+      if (advisor.batchFixes.length > 0) {
+        lines.push(`
+### \u{1F527} Batch Fixes
+`);
+        for (const fix of advisor.batchFixes) {
+          lines.push(`\`\`\`sql
+${fix.sql}
+\`\`\`
+`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ overview, advisor, exportedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_diff", "Compare current health with last saved snapshot", {}, async () => {
+  try {
+    const prev = loadSnapshot(dataDir);
+    const current = await getAdvisorReport(pool, longQueryThreshold);
+    if (!prev) {
+      saveSnapshot(dataDir, current);
+      return { content: [{ type: "text", text: JSON.stringify({ message: "No previous snapshot found. Current result saved as baseline.", score: current.score, grade: current.grade, issues: current.issues.length }, null, 2) }] };
+    }
+    const diff = diffSnapshots(prev.result, current);
+    saveSnapshot(dataDir, current);
+    return { content: [{ type: "text", text: JSON.stringify({ ...diff, previousTimestamp: prev.timestamp }, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
 var transport = new StdioServerTransport();
 await server.connect(transport);
 //# sourceMappingURL=mcp.js.map