@indiekitai/pg-dash 0.2.0

package/dist/mcp.js

@@ -0,0 +1,940 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Pool } from "pg";
+import { z } from "zod";
+
+// src/server/queries/overview.ts
+async function getOverview(pool2) {
+  const client = await pool2.connect();
+  try {
+    const version = await client.query("SHOW server_version");
+    const uptime = await client.query(
+      "SELECT now() - pg_postmaster_start_time() AS uptime"
+    );
+    const dbSize = await client.query(
+      "SELECT pg_size_pretty(pg_database_size(current_database())) AS size"
+    );
+    const dbCount = await client.query(
+      "SELECT count(*)::int AS count FROM pg_database WHERE NOT datistemplate"
+    );
+    const connections = await client.query(`
+      SELECT
+        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'active') AS active,
+        (SELECT count(*)::int FROM pg_stat_activity WHERE state = 'idle') AS idle,
+        (SELECT setting::int FROM pg_settings WHERE name = 'max_connections') AS max
+    `);
+    return {
+      version: version.rows[0].server_version,
+      uptime: uptime.rows[0].uptime,
+      dbSize: dbSize.rows[0].size,
+      databaseCount: dbCount.rows[0].count,
+      connections: connections.rows[0]
+    };
+  } finally {
+    client.release();
+  }
+}
+
+// src/server/queries/tables.ts
+async function getTables(pool2) {
+  const client = await pool2.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        schemaname AS schema,
+        relname AS name,
+        pg_size_pretty(pg_total_relation_size(relid)) AS total_size,
+        pg_total_relation_size(relid) AS size_bytes,
+        n_live_tup AS rows,
+        n_dead_tup AS dead_tuples,
+        CASE WHEN n_live_tup > 0 
+          THEN round(n_dead_tup::numeric / n_live_tup * 100, 1) 
+          ELSE 0 END AS dead_pct
+      FROM pg_stat_user_tables
+      ORDER BY pg_total_relation_size(relid) DESC
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
+
+// src/server/queries/schema.ts
+async function getSchemaTableDetail(pool2, tableName) {
+  const client = await pool2.connect();
+  try {
+    const parts = tableName.split(".");
+    const schema = parts.length > 1 ? parts[0] : "public";
+    const name = parts.length > 1 ? parts[1] : parts[0];
+    const tableInfo = await client.query(`
+      SELECT
+        c.relname AS name, n.nspname AS schema,
+        pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+        pg_size_pretty(pg_relation_size(c.oid)) AS table_size,
+        pg_size_pretty(pg_total_relation_size(c.oid) - pg_relation_size(c.oid)) AS index_size,
+        pg_size_pretty(pg_relation_size(c.reltoastrelid)) AS toast_size,
+        s.n_live_tup AS row_count, s.n_dead_tup AS dead_tuples,
+        s.last_vacuum, s.last_autovacuum, s.last_analyze, s.last_autoanalyze,
+        s.seq_scan, s.idx_scan
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      LEFT JOIN pg_stat_user_tables s ON s.relid = c.oid
+      WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'
+    `, [name, schema]);
+    if (tableInfo.rows.length === 0) return null;
+    const columns = await client.query(`
+      SELECT
+        a.attname AS name,
+        pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
+        NOT a.attnotnull AS nullable,
+        pg_get_expr(d.adbin, d.adrelid) AS default_value,
+        col_description(a.attrelid, a.attnum) AS description
+      FROM pg_attribute a
+      LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+      WHERE a.attrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
+        AND a.attnum > 0 AND NOT a.attisdropped
+      ORDER BY a.attnum
+    `, [name, schema]);
+    const indexes = await client.query(`
+      SELECT
+        i.relname AS name,
+        am.amname AS type,
+        pg_size_pretty(pg_relation_size(i.oid)) AS size,
+        pg_get_indexdef(idx.indexrelid) AS definition,
+        idx.indisunique AS is_unique,
+        idx.indisprimary AS is_primary,
+        s.idx_scan, s.idx_tup_read, s.idx_tup_fetch
+      FROM pg_index idx
+      JOIN pg_class i ON idx.indexrelid = i.oid
+      JOIN pg_class t ON idx.indrelid = t.oid
+      JOIN pg_namespace n ON t.relnamespace = n.oid
+      JOIN pg_am am ON i.relam = am.oid
+      LEFT JOIN pg_stat_user_indexes s ON s.indexrelid = i.oid
+      WHERE t.relname = $1 AND n.nspname = $2
+      ORDER BY i.relname
+    `, [name, schema]);
+    const constraints = await client.query(`
+      SELECT
+        conname AS name,
+        CASE contype WHEN 'p' THEN 'PRIMARY KEY' WHEN 'f' THEN 'FOREIGN KEY'
+          WHEN 'u' THEN 'UNIQUE' WHEN 'c' THEN 'CHECK' WHEN 'x' THEN 'EXCLUDE' END AS type,
+        pg_get_constraintdef(oid) AS definition
+      FROM pg_constraint
+      WHERE conrelid = (SELECT c.oid FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2)
+      ORDER BY
+        CASE contype WHEN 'p' THEN 1 WHEN 'u' THEN 2 WHEN 'f' THEN 3 WHEN 'c' THEN 4 ELSE 5 END
+    `, [name, schema]);
+    const foreignKeys = await client.query(`
+      SELECT
+        conname AS name,
+        a.attname AS column_name,
+        confrelid::regclass::text AS referenced_table,
+        af.attname AS referenced_column
+      FROM pg_constraint c
+      JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+      JOIN pg_attribute af ON af.attrelid = c.confrelid AND af.attnum = ANY(c.confkey)
+      WHERE c.contype = 'f'
+        AND c.conrelid = (SELECT cl.oid FROM pg_class cl JOIN pg_namespace n ON cl.relnamespace = n.oid WHERE cl.relname = $1 AND n.nspname = $2)
+    `, [name, schema]);
+    let sampleData = [];
+    try {
+      const sample = await client.query(
+        `SELECT * FROM ${client.escapeIdentifier(schema)}.${client.escapeIdentifier(name)} LIMIT 10`
+      );
+      sampleData = sample.rows;
+    } catch (err) {
+      console.error("[schema] Error:", err.message);
+    }
+    return {
+      ...tableInfo.rows[0],
+      columns: columns.rows,
+      indexes: indexes.rows,
+      constraints: constraints.rows,
+      foreignKeys: foreignKeys.rows,
+      sampleData
+    };
+  } finally {
+    client.release();
+  }
+}
+
+// src/server/queries/activity.ts
+async function getActivity(pool2) {
+  const client = await pool2.connect();
+  try {
+    const r = await client.query(`
+      SELECT
+        pid,
+        COALESCE(query, '') AS query,
+        COALESCE(state, 'unknown') AS state,
+        wait_event,
+        wait_event_type,
+        CASE WHEN state = 'active' THEN (now() - query_start)::text
+             WHEN state = 'idle in transaction' THEN (now() - state_change)::text
+             ELSE NULL END AS duration,
+        client_addr::text,
+        COALESCE(application_name, '') AS application_name,
+        backend_start::text
+      FROM pg_stat_activity
+      WHERE pid != pg_backend_pid()
+        AND state IS NOT NULL
+      ORDER BY
+        CASE state
+          WHEN 'active' THEN 1
+          WHEN 'idle in transaction' THEN 2
+          ELSE 3
+        END,
+        query_start ASC NULLS LAST
+    `);
+    return r.rows;
+  } finally {
+    client.release();
+  }
+}
+
+// src/server/advisor.ts
+var SEVERITY_WEIGHT = { critical: 20, warning: 8, info: 3 };
+function computeAdvisorScore(issues) {
+  let score = 100;
+  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;
+  }
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+function gradeFromScore(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 50) return "D";
+  return "F";
+}
+function computeBreakdown(issues) {
+  const categories = ["performance", "maintenance", "schema", "security"];
+  const result = {};
+  for (const cat of categories) {
+    const catIssues = issues.filter((i) => i.category === cat);
+    const score = computeAdvisorScore(catIssues);
+    result[cat] = { score, grade: gradeFromScore(score), count: catIssues.length };
+  }
+  return result;
+}
+async function getAdvisorReport(pool2) {
+  const client = await pool2.connect();
+  const issues = [];
+  try {
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname, seq_scan, seq_tup_read, n_live_tup,
+          pg_size_pretty(pg_total_relation_size(relid)) AS size
+        FROM pg_stat_user_tables
+        WHERE n_live_tup > 10000 AND seq_scan > 100
+        ORDER BY seq_tup_read DESC LIMIT 10
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `perf-seq-scan-${row.schemaname}-${row.relname}`,
+          severity: row.seq_scan > 1e3 ? "warning" : "info",
+          category: "performance",
+          title: `High sequential scans on ${row.relname}`,
+          description: `Table ${row.schemaname}.${row.relname} (${row.n_live_tup} rows, ${row.size}) has ${row.seq_scan} sequential scans reading ${Number(row.seq_tup_read).toLocaleString()} tuples. Consider adding indexes on frequently filtered columns.`,
+          fix: `-- Identify commonly filtered columns and add indexes:
+-- EXPLAIN ANALYZE SELECT * FROM ${row.schemaname}.${row.relname} WHERE <your_condition>;
+CREATE INDEX CONCURRENTLY idx_${row.relname}_<column> ON ${row.schemaname}.${row.relname} (<column>);`,
+          impact: "Queries will continue to do full table scans, degrading performance as the table grows.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking seq scans:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT
+          schemaname, relname, indexrelname,
+          pg_relation_size(indexrelid) AS idx_size,
+          pg_relation_size(relid) AS tbl_size,
+          pg_size_pretty(pg_relation_size(indexrelid)) AS idx_size_pretty,
+          pg_size_pretty(pg_relation_size(relid)) AS tbl_size_pretty
+        FROM pg_stat_user_indexes
+        WHERE pg_relation_size(indexrelid) > 1048576
+          AND pg_relation_size(indexrelid) > pg_relation_size(relid) * 3
+        ORDER BY pg_relation_size(indexrelid) DESC LIMIT 10
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `perf-bloated-idx-${row.indexrelname}`,
+          severity: "warning",
+          category: "performance",
+          title: `Bloated index ${row.indexrelname}`,
+          description: `Index ${row.indexrelname} on ${row.relname} is ${row.idx_size_pretty} but the table is only ${row.tbl_size_pretty}. The index may need rebuilding.`,
+          fix: `REINDEX INDEX CONCURRENTLY ${row.schemaname}.${row.indexrelname};`,
+          impact: "Bloated indexes waste disk space and slow down queries that use them.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking bloated indexes:", err.message);
+    }
+    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,
+          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
+      `);
+      for (const row of r.rows) {
+        const pct = parseFloat(row.dead_pct);
+        issues.push({
+          id: `perf-bloat-${row.schemaname}-${row.relname}`,
+          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}.`,
+          fix: `VACUUM FULL ${row.schemaname}.${row.relname};`,
+          impact: "Dead tuples waste storage and degrade scan performance.",
+          effort: pct > 30 ? "moderate" : "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking table bloat:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname,
+          heap_blks_hit, heap_blks_read,
+          CASE WHEN (heap_blks_hit + heap_blks_read) = 0 THEN 1
+            ELSE heap_blks_hit::float / (heap_blks_hit + heap_blks_read) END AS ratio
+        FROM pg_statio_user_tables
+        WHERE (heap_blks_hit + heap_blks_read) > 100
+        ORDER BY ratio ASC LIMIT 5
+      `);
+      for (const row of r.rows) {
+        const ratio = parseFloat(row.ratio);
+        if (ratio < 0.9) {
+          issues.push({
+            id: `perf-cache-${row.schemaname}-${row.relname}`,
+            severity: ratio < 0.5 ? "critical" : "warning",
+            category: "performance",
+            title: `Poor cache hit ratio on ${row.relname}`,
+            description: `Table ${row.schemaname}.${row.relname} has a cache hit ratio of ${(ratio * 100).toFixed(1)}%. Most reads are going to disk.`,
+            fix: `-- Consider increasing shared_buffers or reducing working set:
+SHOW shared_buffers;`,
+            impact: "Disk reads are orders of magnitude slower than memory reads.",
+            effort: "involved"
+          });
+        }
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking cache efficiency:", err.message);
+    }
+    try {
+      const extCheck = await client.query("SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'");
+      if (extCheck.rows.length > 0) {
+        const r = await client.query(`
+          SELECT query, calls, mean_exec_time, total_exec_time,
+            round(mean_exec_time::numeric, 2) AS mean_ms,
+            round(total_exec_time::numeric / 1000, 2) AS total_sec
+          FROM pg_stat_statements
+          WHERE query NOT LIKE '%pg_stat%' AND query NOT LIKE '%pg_catalog%'
+            AND mean_exec_time > 100
+          ORDER BY mean_exec_time DESC LIMIT 5
+        `);
+        for (const row of r.rows) {
+          issues.push({
+            id: `perf-slow-${row.query.slice(0, 30).replace(/\W/g, "_")}`,
+            severity: parseFloat(row.mean_ms) > 1e3 ? "warning" : "info",
+            category: "performance",
+            title: `Slow query (avg ${row.mean_ms}ms)`,
+            description: `Query averaging ${row.mean_ms}ms over ${row.calls} calls (total: ${row.total_sec}s): ${row.query.slice(0, 200)}`,
+            fix: `EXPLAIN ANALYZE ${row.query.slice(0, 500)};`,
+            impact: "Slow queries degrade overall database responsiveness.",
+            effort: "moderate"
+          });
+        }
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking slow queries:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname, last_vacuum, last_autovacuum, n_dead_tup
+        FROM pg_stat_user_tables
+        WHERE n_live_tup > 100
+          AND (last_vacuum IS NULL AND last_autovacuum IS NULL
+               OR GREATEST(last_vacuum, last_autovacuum) < now() - interval '7 days')
+        ORDER BY n_dead_tup DESC LIMIT 15
+      `);
+      for (const row of r.rows) {
+        const never = !row.last_vacuum && !row.last_autovacuum;
+        issues.push({
+          id: `maint-vacuum-${row.schemaname}-${row.relname}`,
+          severity: never ? "warning" : "info",
+          category: "maintenance",
+          title: `VACUUM ${never ? "never run" : "overdue"} on ${row.relname}`,
+          description: `${row.schemaname}.${row.relname} ${never ? "has never been vacuumed" : "was last vacuumed over 7 days ago"}. Dead tuples: ${Number(row.n_dead_tup).toLocaleString()}.`,
+          fix: `VACUUM ANALYZE ${row.schemaname}.${row.relname};`,
+          impact: "Dead tuples accumulate, increasing table size and degrading query performance.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking vacuum overdue:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname
+        FROM pg_stat_user_tables
+        WHERE n_live_tup > 100
+          AND last_analyze IS NULL AND last_autoanalyze IS NULL
+          AND NOT EXISTS (
+            SELECT 1 FROM pg_stat_user_tables t2
+            WHERE t2.relname = pg_stat_user_tables.relname
+              AND (t2.last_vacuum IS NULL AND t2.last_autovacuum IS NULL)
+          )
+        LIMIT 10
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `maint-analyze-${row.schemaname}-${row.relname}`,
+          severity: "info",
+          category: "maintenance",
+          title: `ANALYZE never run on ${row.relname}`,
+          description: `${row.schemaname}.${row.relname} has never been analyzed. The query planner may choose suboptimal plans.`,
+          fix: `ANALYZE ${row.schemaname}.${row.relname};`,
+          impact: "Without statistics, the query planner makes poor estimates leading to slow queries.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking analyze overdue:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT datname, age(datfrozenxid) AS xid_age
+        FROM pg_database
+        WHERE datname = current_database()
+      `);
+      for (const row of r.rows) {
+        const age = parseInt(row.xid_age);
+        if (age > 1e9) {
+          issues.push({
+            id: `maint-xid-wraparound`,
+            severity: "critical",
+            category: "maintenance",
+            title: `Transaction ID wraparound risk`,
+            description: `Database ${row.datname} has datfrozenxid age of ${age.toLocaleString()}. Wraparound occurs at ~2 billion.`,
+            fix: `VACUUM FREEZE;`,
+            impact: "If wraparound occurs, PostgreSQL will shut down to prevent data loss.",
+            effort: "involved"
+          });
+        } else if (age > 5e8) {
+          issues.push({
+            id: `maint-xid-warning`,
+            severity: "warning",
+            category: "maintenance",
+            title: `Transaction ID age is high`,
+            description: `Database ${row.datname} has datfrozenxid age of ${age.toLocaleString()}.`,
+            fix: `VACUUM FREEZE;`,
+            impact: "Approaching transaction ID wraparound threshold.",
+            effort: "moderate"
+          });
+        }
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking xid wraparound:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT pid, state, now() - state_change AS idle_duration,
+          client_addr::text, application_name,
+          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 '10 minutes'
+          AND pid != pg_backend_pid()
+      `);
+      for (const row of r.rows) {
+        const isIdleTx = row.state === "idle in transaction";
+        issues.push({
+          id: `maint-idle-${row.pid}`,
+          severity: isIdleTx ? "warning" : "info",
+          category: "maintenance",
+          title: `${isIdleTx ? "Idle in transaction" : "Idle connection"} (PID ${row.pid})`,
+          description: `PID ${row.pid} from ${row.client_addr || "local"} (${row.application_name || "unknown"}) has been ${row.state} for ${Math.round(row.idle_seconds / 60)} minutes.`,
+          fix: `SELECT pg_terminate_backend(${row.pid});`,
+          impact: isIdleTx ? "Idle-in-transaction connections hold locks and prevent VACUUM." : "Idle connections consume connection slots.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking idle connections:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT c.relname AS table_name, n.nspname AS schema
+        FROM pg_class c
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE c.relkind = 'r' AND n.nspname = 'public'
+          AND NOT EXISTS (
+            SELECT 1 FROM pg_constraint con WHERE con.conrelid = c.oid AND con.contype = 'p'
+          )
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `schema-no-pk-${row.schema}-${row.table_name}`,
+          severity: "warning",
+          category: "schema",
+          title: `Missing primary key on ${row.table_name}`,
+          description: `Table ${row.schema}.${row.table_name} has no primary key. This can cause replication issues and makes row identification unreliable.`,
+          fix: `ALTER TABLE ${row.schema}.${row.table_name} ADD PRIMARY KEY (<column>);`,
+          impact: "No primary key means no unique row identity, problematic for replication and ORMs.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking missing primary keys:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT schemaname, relname, indexrelname, idx_scan,
+          pg_size_pretty(pg_relation_size(indexrelid)) AS idx_size,
+          pg_relation_size(indexrelid) AS idx_bytes
+        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
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `schema-unused-idx-${row.indexrelname}`,
+          severity: "warning",
+          category: "schema",
+          title: `Unused index ${row.indexrelname} (${row.idx_size})`,
+          description: `Index ${row.indexrelname} on ${row.relname} has never been used (0 scans) and takes ${row.idx_size}.`,
+          fix: `DROP INDEX CONCURRENTLY ${row.schemaname}.${row.indexrelname};`,
+          impact: "Unused indexes waste disk space and slow down writes.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking unused indexes:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT array_agg(idx.indexrelid::regclass::text) AS indexes,
+          idx.indrelid::regclass::text AS table_name,
+          pg_size_pretty(sum(pg_relation_size(idx.indexrelid))) AS total_size
+        FROM pg_index idx
+        GROUP BY idx.indrelid, idx.indkey
+        HAVING count(*) > 1
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `schema-dup-idx-${row.table_name}-${row.indexes[0]}`,
+          severity: "warning",
+          category: "schema",
+          title: `Duplicate indexes on ${row.table_name}`,
+          description: `These indexes cover the same columns on ${row.table_name}: ${row.indexes.join(", ")}. Total wasted space: ${row.total_size}.`,
+          fix: `-- Keep one, drop the rest:
+DROP INDEX CONCURRENTLY ${row.indexes.slice(1).join(";\nDROP INDEX CONCURRENTLY ")};`,
+          impact: "Duplicate indexes double the write overhead and waste disk space.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking duplicate indexes:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT
+          conrelid::regclass::text AS table_name,
+          a.attname AS column_name,
+          confrelid::regclass::text AS referenced_table
+        FROM pg_constraint c
+        JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+        WHERE c.contype = 'f'
+          AND NOT EXISTS (
+            SELECT 1 FROM pg_index i
+            WHERE i.indrelid = c.conrelid
+              AND a.attnum = ANY(i.indkey)
+          )
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `schema-fk-no-idx-${row.table_name}-${row.column_name}`,
+          severity: "warning",
+          category: "schema",
+          title: `Missing index on FK column ${row.table_name}.${row.column_name}`,
+          description: `Foreign key column ${row.column_name} on ${row.table_name} (references ${row.referenced_table}) has no index. This causes slow JOINs and cascading deletes.`,
+          fix: `CREATE INDEX CONCURRENTLY idx_${row.table_name.replace(/\./g, "_")}_${row.column_name} ON ${row.table_name} (${row.column_name});`,
+          impact: "JOINs and cascading deletes on this FK will require full table scans.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking missing FK indexes:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT blocked_locks.pid AS blocked_pid,
+          blocking_locks.pid AS blocking_pid,
+          blocked_activity.query AS blocked_query
+        FROM pg_catalog.pg_locks blocked_locks
+        JOIN pg_catalog.pg_locks blocking_locks ON blocking_locks.locktype = blocked_locks.locktype
+          AND blocking_locks.database IS NOT DISTINCT FROM blocked_locks.database
+          AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation
+          AND blocking_locks.page IS NOT DISTINCT FROM blocked_locks.page
+          AND blocking_locks.tuple IS NOT DISTINCT FROM blocked_locks.tuple
+          AND blocking_locks.virtualxid IS NOT DISTINCT FROM blocked_locks.virtualxid
+          AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
+          AND blocking_locks.classid IS NOT DISTINCT FROM blocked_locks.classid
+          AND blocking_locks.objid IS NOT DISTINCT FROM blocked_locks.objid
+          AND blocking_locks.objsubid IS NOT DISTINCT FROM blocked_locks.objsubid
+          AND blocking_locks.pid != blocked_locks.pid
+        JOIN pg_catalog.pg_stat_activity blocked_activity ON blocked_activity.pid = blocked_locks.pid
+        WHERE NOT blocked_locks.granted
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `perf-lock-blocked-${row.blocked_pid}`,
+          severity: "warning",
+          category: "performance",
+          title: `Blocked query (PID ${row.blocked_pid} blocked by PID ${row.blocking_pid})`,
+          description: `PID ${row.blocked_pid} is waiting for a lock held by PID ${row.blocking_pid}. Query: ${(row.blocked_query || "").slice(0, 200)}`,
+          fix: `SELECT pg_cancel_backend(${row.blocking_pid});`,
+          impact: "Blocked queries cause cascading delays and potential timeouts.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking locks:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT CASE WHEN pg_is_in_recovery()
+          THEN pg_wal_lsn_diff(pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn())
+          ELSE 0 END AS lag_bytes
+      `);
+      const lagBytes = parseInt(r.rows[0]?.lag_bytes ?? "0");
+      if (lagBytes > 1048576) {
+        issues.push({
+          id: `perf-replication-lag`,
+          severity: lagBytes > 104857600 ? "critical" : "warning",
+          category: "performance",
+          title: `Replication lag: ${(lagBytes / 1048576).toFixed(1)} MB`,
+          description: `WAL replay is lagging by ${(lagBytes / 1048576).toFixed(1)} MB. This indicates the replica is falling behind.`,
+          fix: `-- Check replication status:
+SELECT * FROM pg_stat_replication;`,
+          impact: "High replication lag means the replica has stale data and failover may lose transactions.",
+          effort: "involved"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking replication lag:", err.message);
+    }
+    try {
+      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
+      `);
+      const reqPct = parseFloat(r.rows[0]?.req_pct ?? "0");
+      if (reqPct > 50) {
+        issues.push({
+          id: `maint-checkpoint-frequency`,
+          severity: reqPct > 80 ? "warning" : "info",
+          category: "maintenance",
+          title: `${reqPct}% of checkpoints are requested (not timed)`,
+          description: `${r.rows[0]?.checkpoints_req} requested vs ${r.rows[0]?.checkpoints_timed} timed checkpoints. High requested checkpoints indicate checkpoint_completion_target or max_wal_size may need tuning.`,
+          fix: `-- Increase max_wal_size:
+ALTER SYSTEM SET max_wal_size = '2GB';
+SELECT pg_reload_conf();`,
+          impact: "Frequent requested checkpoints cause I/O spikes and degrade performance.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking checkpoint frequency:", err.message);
+    }
+    try {
+      const r = await client.query(`SELECT setting FROM pg_settings WHERE name = 'autovacuum'`);
+      if (r.rows[0]?.setting === "off") {
+        issues.push({
+          id: `maint-autovacuum-disabled`,
+          severity: "critical",
+          category: "maintenance",
+          title: `Autovacuum is disabled`,
+          description: `Autovacuum is turned off. Dead tuples will accumulate and transaction ID wraparound becomes a risk.`,
+          fix: `ALTER SYSTEM SET autovacuum = on;
+SELECT pg_reload_conf();`,
+          impact: "Without autovacuum, tables bloat indefinitely and risk transaction ID wraparound shutdown.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking autovacuum:", err.message);
+    }
+    try {
+      const sbRes = await client.query(`SELECT setting, unit FROM pg_settings WHERE name = 'shared_buffers'`);
+      const memRes = await client.query(`
+        SELECT (SELECT setting::bigint FROM pg_settings WHERE name = 'shared_buffers') *
+               (SELECT setting::bigint FROM pg_settings WHERE name = 'block_size') AS shared_bytes
+      `);
+      const sharedBytes = parseInt(memRes.rows[0]?.shared_bytes ?? "0");
+      if (sharedBytes > 0 && sharedBytes < 128 * 1024 * 1024) {
+        issues.push({
+          id: `perf-shared-buffers-low`,
+          severity: "warning",
+          category: "performance",
+          title: `shared_buffers is only ${(sharedBytes / 1048576).toFixed(0)} MB`,
+          description: `shared_buffers is set to ${sbRes.rows[0]?.setting}${sbRes.rows[0]?.unit || ""}. Recommended: ~25% of system RAM, typically at least 256MB for production.`,
+          fix: `ALTER SYSTEM SET shared_buffers = '256MB';
+-- Requires restart`,
+          impact: "Low shared_buffers means more disk I/O and poor cache hit ratios.",
+          effort: "involved"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking shared_buffers:", err.message);
+    }
+    try {
+      const r = await client.query(`SELECT setting, unit FROM pg_settings WHERE name = 'work_mem'`);
+      const workMemKB = parseInt(r.rows[0]?.setting ?? "0");
+      if (workMemKB > 0 && workMemKB < 4096) {
+        issues.push({
+          id: `perf-work-mem-low`,
+          severity: "info",
+          category: "performance",
+          title: `work_mem is only ${workMemKB < 1024 ? workMemKB + "kB" : (workMemKB / 1024).toFixed(0) + "MB"}`,
+          description: `work_mem is ${r.rows[0]?.setting}${r.rows[0]?.unit || ""}. Low work_mem causes sorts and hash operations to spill to disk.`,
+          fix: `ALTER SYSTEM SET work_mem = '16MB';
+SELECT pg_reload_conf();`,
+          impact: "Operations that exceed work_mem use temporary disk files, which is much slower.",
+          effort: "quick"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking work_mem:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT pid, usename, client_addr::text
+        FROM pg_stat_activity
+        WHERE usename IN (SELECT rolname FROM pg_roles WHERE rolsuper)
+          AND client_addr IS NOT NULL
+          AND client_addr::text NOT IN ('127.0.0.1', '::1')
+          AND pid != pg_backend_pid()
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `sec-superuser-remote-${row.pid}`,
+          severity: "critical",
+          category: "security",
+          title: `Superuser ${row.usename} connected from ${row.client_addr}`,
+          description: `Superuser ${row.usename} has an active connection from non-localhost address ${row.client_addr}. This is a security risk.`,
+          fix: `-- Restrict superuser access in pg_hba.conf to localhost only.
+-- Then: SELECT pg_reload_conf();`,
+          impact: "Remote superuser access is a significant security vulnerability.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking superuser connections:", err.message);
+    }
+    try {
+      const r = await client.query(`SELECT setting FROM pg_settings WHERE name = 'ssl'`);
+      if (r.rows[0]?.setting === "off") {
+        issues.push({
+          id: `sec-ssl-off`,
+          severity: "warning",
+          category: "security",
+          title: `SSL is disabled`,
+          description: `SSL is turned off. Database connections are not encrypted.`,
+          fix: `-- Enable SSL in postgresql.conf:
+-- ssl = on
+-- ssl_cert_file = 'server.crt'
+-- ssl_key_file = 'server.key'
+SELECT pg_reload_conf();`,
+          impact: "Database traffic can be intercepted and read in transit.",
+          effort: "involved"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking SSL check:", err.message);
+    }
+    try {
+      const r = await client.query(`
+        SELECT type, database, user_name, auth_method
+        FROM pg_hba_file_rules
+        WHERE auth_method = 'trust' AND type != 'local'
+        LIMIT 5
+      `);
+      for (const row of r.rows) {
+        issues.push({
+          id: `sec-trust-auth-${row.database}-${row.user_name}`,
+          severity: "critical",
+          category: "security",
+          title: `Trust authentication for ${row.user_name}@${row.database}`,
+          description: `HBA rule allows trust (no password) authentication for ${row.type} connections to ${row.database} as ${row.user_name}.`,
+          fix: `-- Change auth_method from 'trust' to 'scram-sha-256' in pg_hba.conf
+-- Then: SELECT pg_reload_conf();`,
+          impact: "Anyone can connect without a password.",
+          effort: "moderate"
+        });
+      }
+    } catch (err) {
+      console.error("[advisor] Error checking trust auth:", err.message);
+    }
+    const score = computeAdvisorScore(issues);
+    return {
+      score,
+      grade: gradeFromScore(score),
+      issues,
+      breakdown: computeBreakdown(issues)
+    };
+  } finally {
+    client.release();
+  }
+}
+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();
+  if (upper.startsWith("EXPLAIN ANALYZE")) {
+    const afterExplain = upper.replace(/^EXPLAIN\s+ANALYZE\s+/, "").trimStart();
+    return afterExplain.startsWith("SELECT");
+  }
+  const ALLOWED_PREFIXES = [
+    "VACUUM",
+    "ANALYZE",
+    "REINDEX",
+    "CREATE INDEX CONCURRENTLY",
+    "DROP INDEX CONCURRENTLY",
+    "SELECT PG_TERMINATE_BACKEND(",
+    "SELECT PG_CANCEL_BACKEND("
+  ];
+  return ALLOWED_PREFIXES.some((p) => upper.startsWith(p));
+}
+
+// src/mcp.ts
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import fs from "fs";
+var connString = process.argv[2] || process.env.PG_DASH_CONNECTION_STRING;
+if (!connString) {
+  console.error("Usage: pg-dash-mcp <connection-string>");
+  console.error("  or set PG_DASH_CONNECTION_STRING env var");
+  process.exit(1);
+}
+var pool = new Pool({ connectionString: connString });
+var dataDir = process.env.PG_DASH_DATA_DIR || path.join(os.homedir(), ".pg-dash");
+fs.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 });
+} 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 });
+} catch (err) {
+  console.error("[mcp] Error:", err.message);
+}
+var server = new McpServer({ name: "pg-dash", version: "0.1.0" });
+server.tool("pg_dash_overview", "Get database overview (version, uptime, size, connections)", {}, async () => {
+  try {
+    const data = await getOverview(pool);
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_health", "Get health advisor report with score, grade, and issues", {}, async () => {
+  try {
+    const data = await getAdvisorReport(pool);
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_tables", "List all tables with sizes and row counts", {}, async () => {
+  try {
+    const data = await getTables(pool);
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_table_detail", "Get detailed info about a specific table", { table: z.string().describe("Table name (e.g. 'users' or 'public.users')") }, async ({ table }) => {
+  try {
+    const data = await getSchemaTableDetail(pool, table);
+    if (!data) return { content: [{ type: "text", text: "Table not found" }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_activity", "Get current database activity (active queries, connections)", {}, async () => {
+  try {
+    const data = await getActivity(pool);
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_schema_changes", "Get recent schema changes", {}, async () => {
+  try {
+    if (!schemaDb) return { content: [{ type: "text", text: "No schema tracking data available. Run pg-dash server first." }] };
+    const changes = schemaDb.prepare("SELECT * FROM schema_changes ORDER BY timestamp DESC LIMIT 50").all();
+    return { content: [{ type: "text", text: JSON.stringify(changes, null, 2) }] };
+  } catch (err) {
+    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 }) => {
+  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 };
+    const client = await pool.connect();
+    try {
+      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) }] };
+    } finally {
+      client.release();
+    }
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_alerts", "Get alert history", {}, async () => {
+  try {
+    if (!alertsDb) return { content: [{ type: "text", text: "No alerts data available. Run pg-dash server first." }] };
+    const history = alertsDb.prepare("SELECT * FROM alert_history ORDER BY timestamp DESC LIMIT 50").all();
+    return { content: [{ type: "text", text: JSON.stringify(history, 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