@indiekitai/pg-dash 0.3.9 → 0.4.1

package/README.md

@@ -2,7 +2,7 @@
 
 # pg-dash
 
-**The AI-native PostgreSQL health checker.** One command to audit your database, 18 MCP tools for AI-assisted optimization, CI integration for automated checks.
+**The AI-native PostgreSQL health checker.** One command to audit your database, 23 MCP tools for AI-assisted optimization, CI integration for automated checks.
 
 Not another monitoring dashboard — pg-dash is built to fit into your **AI coding workflow**:
 
@@ -47,7 +47,7 @@ The Dashboard is there when you need it. But the real power is in the CLI, MCP,
 | pganalyze | $149+/mo | SaaS signup | ❌ | ❌ |
 | Grafana+Prometheus | Free | 3 services | ❌ | ❌ |
 | pgAdmin | Free | Complex UI | ❌ | ❌ |
-| **pg-dash** | **Free** | **One command** | **18 MCP tools** | **`--ci --diff`** |
+| **pg-dash** | **Free** | **One command** | **23 MCP tools** | **`--ci --diff`** |
 
 ## Features
 
@@ -117,8 +117,15 @@ The Dashboard is there when you need it. But the real power is in the CLI, MCP,
 - `--health` flag adds health score comparison and unique issues per environment
 - `pg_dash_compare_env` MCP tool: ask your AI "what's different between local and staging?"
 
+### 🔧 Production Readiness Audit
+- **Unused indexes** — Find indexes with 0 scans since last stats reset; suggests safe `DROP INDEX CONCURRENTLY` SQL
+- **Table bloat** — Dead tuple ratio per table (≥10%); surfaces both `last_autovacuum` and `last_vacuum` timestamps
+- **Autovacuum health** — Classifies each table as `ok` / `stale` / `overdue` / `never`; shows autovacuum settings with units
+- **Lock monitoring** — Active lock-wait chains (who is blocking whom) + long-running queries >5s
+- **Config recommendations** — Audits `shared_buffers`, `work_mem`, `checkpoint_completion_target`, `random_page_cost`, `idle_in_transaction_session_timeout`, and 5 more settings with severity-tagged recommendations
+
 ### 🤖 MCP Server
-- 18 tools for AI agent integration
+- 23 tools for AI agent integration
 - `pg-dash-mcp postgres://...` — works with Claude, Cursor, etc.
 
 ### 🖥️ CLI
@@ -202,7 +209,7 @@ pg-dash-mcp postgres://user:pass@host/db
 PG_DASH_CONNECTION_STRING=postgres://... pg-dash-mcp
 ```
 
-### Available Tools (18)
+### Available Tools (23)
 
 | Tool | Description |
 |------|-------------|
@@ -224,6 +231,11 @@ PG_DASH_CONNECTION_STRING=postgres://... pg-dash-mcp
 | `pg_dash_analyze_query` | Deep EXPLAIN analysis with automatic index suggestions |
 | `pg_dash_query_regressions` | Detect queries that degraded >50% vs historical baseline |
 | `pg_dash_compare_env` | Compare schema and health between two database environments |
+| `pg_dash_unused_indexes` | Find unused indexes that waste space and slow down writes |
+| `pg_dash_bloat` | Detect table bloat (dead tuples) that slow down queries |
+| `pg_dash_autovacuum` | Check autovacuum health — which tables are stale or never vacuumed |
+| `pg_dash_locks` | Show active lock waits and long-running blocking queries |
+| `pg_dash_config_check` | Audit PostgreSQL configuration and get tuning recommendations |
 
 ## MCP Setup
 

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 # pg-dash
 
-**AI 原生的 PostgreSQL 健康检查工具。** 一条命令审计数据库，18 个 MCP 工具让 AI 帮你优化，CI 集成自动检查。
+**AI 原生的 PostgreSQL 健康检查工具。** 一条命令审计数据库，23 个 MCP 工具让 AI 帮你优化，CI 集成自动检查。
 
 不是又一个监控面板 —— pg-dash 是为 **AI 编程工作流** 设计的：
 
@@ -47,7 +47,7 @@ Dashboard 需要时可以用。但真正的核心能力在 CLI、MCP 和 CI。
 | pganalyze | $149+/月 | SaaS 注册 | ❌ | ❌ |
 | Grafana+Prometheus | 免费 | 配置 3 个服务 | ❌ | ❌ |
 | pgAdmin | 免费 | 界面复杂 | ❌ | ❌ |
-| **pg-dash** | **免费** | **一条命令** | **18 个 MCP 工具** | **`--ci --diff`** |
+| **pg-dash** | **免费** | **一条命令** | **23 个 MCP 工具** | **`--ci --diff`** |
 
 ## 功能
 
@@ -117,8 +117,15 @@ Dashboard 需要时可以用。但真正的核心能力在 CLI、MCP 和 CI。
 - `--health` 参数额外对比健康分和各环境独有的问题
 - `pg_dash_compare_env` MCP 工具：直接问 AI "本地和预发有什么差异？"
 
+### 🔧 生产就绪审计
+- **废弃索引检测** — 找出从未被使用（0 次扫描）的索引，自动生成带引号的 `DROP INDEX CONCURRENTLY` SQL
+- **表膨胀检测** — 统计每张表的 dead tuple 比例（≥10% 才展示），同时显示 `last_autovacuum` 和 `last_vacuum` 时间戳
+- **Autovacuum 健康** — 将每张表分类为 `ok` / `stale` / `overdue` / `never`，展示带单位的 autovacuum 配置
+- **锁监控** — 活跃的锁等待链（谁在阻塞谁）+ 超过 5 秒的长查询
+- **配置建议** — 审计 `shared_buffers`、`work_mem`、`checkpoint_completion_target`、`random_page_cost`、`idle_in_transaction_session_timeout` 等 10 项配置，给出带严重级别的调优建议
+
 ### 🤖 MCP Server
-- 18 个工具，支持 AI Agent 集成
+- 23 个工具，支持 AI Agent 集成
 - `pg-dash-mcp postgres://...` —— 可配合 Claude、Cursor 等使用
 
 ### 🖥️ CLI
@@ -202,7 +209,7 @@ pg-dash-mcp postgres://user:pass@host/db
 PG_DASH_CONNECTION_STRING=postgres://... pg-dash-mcp
 ```
 
-### 可用工具（18 个）
+### 可用工具（23 个）
 
 | 工具 | 描述 |
 |------|------|
@@ -224,6 +231,11 @@ PG_DASH_CONNECTION_STRING=postgres://... pg-dash-mcp
 | `pg_dash_analyze_query` | 深度 EXPLAIN 分析，自动生成索引建议 |
 | `pg_dash_query_regressions` | 检测比历史基线慢超过 50% 的查询 |
 | `pg_dash_compare_env` | 对比两个数据库环境的 Schema 和健康状态 |
+| `pg_dash_unused_indexes` | 发现从未被使用的索引（浪费空间、拖慢写入） |
+| `pg_dash_bloat` | 检测表膨胀（dead tuples 过多） |
+| `pg_dash_autovacuum` | Autovacuum 健康状态——哪些表长期未 vacuum |
+| `pg_dash_locks` | 显示活跃锁等待链和长时间阻塞的查询 |
+| `pg_dash_config_check` | 审计 PostgreSQL 配置，给出调优建议 |
 
 ## MCP 配置
 

package/dist/mcp.js

@@ -1902,6 +1902,480 @@ async function analyzeMigration(sql, pool2) {
   };
 }
 
+// src/server/unused-indexes.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return "< 1 KB";
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  if (bytes < 1024 ** 4) return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  return `${(bytes / 1024 ** 4).toFixed(1)} TB`;
+}
+async function getUnusedIndexes(pool2) {
+  const [indexResult, bgwriterResult] = await Promise.all([
+    pool2.query(`
+      SELECT
+        s.schemaname,
+        s.relname AS table_name,
+        s.indexrelname AS index_name,
+        pg_relation_size(s.indexrelid) AS index_size_bytes,
+        s.idx_scan,
+        i.indexdef
+      FROM pg_stat_user_indexes s
+      JOIN pg_indexes i ON s.schemaname = i.schemaname
+        AND s.relname = i.tablename
+        AND s.indexrelname = i.indexname
+      WHERE s.schemaname = 'public'
+        AND s.idx_scan = 0
+        AND i.indexdef NOT LIKE '%UNIQUE%'
+        AND s.indexrelname NOT LIKE '%_pkey'
+      ORDER BY pg_relation_size(s.indexrelid) DESC
+    `),
+    pool2.query(`SELECT stats_reset FROM pg_stat_bgwriter`)
+  ]);
+  const statsReset = bgwriterResult.rows[0]?.stats_reset ? new Date(bgwriterResult.rows[0].stats_reset).toISOString() : null;
+  const filteredRows = indexResult.rows.filter((row) => {
+    const def = row.indexdef ?? "";
+    if (def.includes(" WHERE ")) return false;
+    const colStart = def.indexOf("(");
+    const colEnd = def.lastIndexOf(")");
+    if (colStart !== -1 && colEnd !== -1) {
+      const cols = def.slice(colStart + 1, colEnd);
+      if (cols.includes("(")) return false;
+    }
+    return true;
+  });
+  const indexes = filteredRows.map((row) => {
+    const sizeBytes = parseInt(row.index_size_bytes, 10) || 0;
+    const index = row.index_name;
+    const table = row.table_name;
+    return {
+      schema: row.schemaname,
+      table,
+      index,
+      indexSize: formatBytes(sizeBytes),
+      indexSizeBytes: sizeBytes,
+      scans: parseInt(row.idx_scan, 10) || 0,
+      lastUsed: statsReset,
+      suggestion: `Index ${index} on ${table} has never been used (0 scans). Consider dropping it: DROP INDEX CONCURRENTLY "${index.replace(/"/g, '""')}"`
+    };
+  });
+  const totalWastedBytes = indexes.reduce((sum, idx) => sum + idx.indexSizeBytes, 0);
+  return {
+    indexes,
+    totalWastedBytes,
+    totalWasted: formatBytes(totalWastedBytes),
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/server/bloat.ts
+function getSuggestion(table, bloatPercent) {
+  if (bloatPercent >= 50) {
+    return `HIGH bloat on ${table} (${bloatPercent}% dead rows). Run: VACUUM ANALYZE ${table}`;
+  } else if (bloatPercent >= 20) {
+    return `Moderate bloat on ${table} (${bloatPercent}% dead rows). Consider VACUUM ANALYZE ${table}`;
+  } else {
+    return `Minor bloat on ${table} (${bloatPercent}% dead rows). Autovacuum should handle this.`;
+  }
+}
+async function getBloatReport(pool2) {
+  const result = await pool2.query(`
+    SELECT
+      schemaname,
+      relname AS table_name,
+      n_live_tup,
+      n_dead_tup,
+      last_autovacuum,
+      last_vacuum
+    FROM pg_stat_user_tables
+    WHERE schemaname = 'public'
+      AND (n_live_tup + n_dead_tup) > 0
+    ORDER BY (n_dead_tup::float / (n_live_tup + n_dead_tup)) DESC
+  `);
+  const tables = [];
+  for (const row of result.rows) {
+    const live = parseInt(row.n_live_tup, 10) || 0;
+    const dead = parseInt(row.n_dead_tup, 10) || 0;
+    const total = live + dead;
+    if (total === 0) continue;
+    const bloatPercent = Math.round(dead / total * 1e3) / 10;
+    if (bloatPercent < 10) continue;
+    const table = row.table_name;
+    tables.push({
+      schema: row.schemaname,
+      table,
+      liveRows: live,
+      deadRows: dead,
+      bloatPercent,
+      lastAutoVacuum: row.last_autovacuum ? new Date(row.last_autovacuum).toISOString() : null,
+      lastVacuum: row.last_vacuum ? new Date(row.last_vacuum).toISOString() : null,
+      suggestion: getSuggestion(table, bloatPercent)
+    });
+  }
+  tables.sort((a, b) => b.bloatPercent - a.bloatPercent);
+  return {
+    tables,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/server/autovacuum.ts
+function classifyStatus(lastAutoVacuum, deadTuples, vacuumCount) {
+  if (lastAutoVacuum === null) return "never";
+  const daysSince = (Date.now() - lastAutoVacuum.getTime()) / (1e3 * 60 * 60 * 24);
+  if (daysSince > 7 && deadTuples > 1e4) return "overdue";
+  if (daysSince > 3) return "stale";
+  return "ok";
+}
+function getSuggestion2(status, table) {
+  switch (status) {
+    case "never":
+      return `Table ${table} has never been autovacuumed. Check if autovacuum is enabled and the table has enough churn.`;
+    case "overdue":
+      return `Table ${table} is overdue for vacuum and has many dead tuples. Run: VACUUM ANALYZE ${table}`;
+    case "stale":
+      return `Table ${table} hasn't been vacuumed in over 3 days. Monitor for bloat.`;
+    case "ok":
+      return null;
+  }
+}
+async function getAutovacuumReport(pool2) {
+  const [tableResult, settingsResult] = await Promise.all([
+    pool2.query(`
+      SELECT
+        schemaname, relname,
+        last_autovacuum, last_autoanalyze,
+        n_dead_tup, n_live_tup,
+        autovacuum_count, autoanalyze_count
+      FROM pg_stat_user_tables
+      WHERE schemaname = 'public'
+      ORDER BY n_dead_tup DESC
+    `),
+    pool2.query(`
+      SELECT name, setting
+      FROM pg_settings
+      WHERE name IN ('autovacuum', 'autovacuum_vacuum_cost_delay', 'autovacuum_max_workers', 'autovacuum_naptime')
+    `)
+  ]);
+  const tables = tableResult.rows.map((row) => {
+    const lastAutoVacuumDate = row.last_autovacuum ? new Date(row.last_autovacuum) : null;
+    const deadTuples = parseInt(row.n_dead_tup, 10) || 0;
+    const liveTuples = parseInt(row.n_live_tup, 10) || 0;
+    const vacuumCount = parseInt(row.autovacuum_count, 10) || 0;
+    const analyzeCount = parseInt(row.autoanalyze_count, 10) || 0;
+    const status = classifyStatus(lastAutoVacuumDate, deadTuples, vacuumCount);
+    const table = row.relname;
+    return {
+      schema: row.schemaname,
+      table,
+      lastAutoVacuum: lastAutoVacuumDate ? lastAutoVacuumDate.toISOString() : null,
+      lastAutoAnalyze: row.last_autoanalyze ? new Date(row.last_autoanalyze).toISOString() : null,
+      deadTuples,
+      liveTuples,
+      vacuumCount,
+      analyzeCount,
+      status,
+      suggestion: getSuggestion2(status, table)
+    };
+  });
+  const settingsMap = /* @__PURE__ */ new Map();
+  for (const row of settingsResult.rows) {
+    settingsMap.set(row.name, row.setting);
+  }
+  return {
+    tables,
+    settings: {
+      autovacuumEnabled: settingsMap.get("autovacuum") !== "off",
+      vacuumCostDelay: `${settingsMap.get("autovacuum_vacuum_cost_delay") ?? "2"}ms`,
+      autovacuumMaxWorkers: parseInt(settingsMap.get("autovacuum_max_workers") ?? "3", 10),
+      autovacuumNaptime: `${settingsMap.get("autovacuum_naptime") ?? "60"}s`
+    },
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/server/locks.ts
+function formatDurationSecs(secs) {
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor(secs % 3600 / 60);
+  const s = secs % 60;
+  return [
+    String(h).padStart(2, "0"),
+    String(m).padStart(2, "0"),
+    String(s).padStart(2, "0")
+  ].join(":");
+}
+async function getLockReport(pool2) {
+  const [locksResult, longResult] = await Promise.all([
+    pool2.query(`
+      SELECT
+        blocked.pid AS blocked_pid,
+        blocked.query AS blocked_query,
+        EXTRACT(EPOCH FROM (NOW() - blocked.query_start))::int AS blocked_secs,
+        blocking.pid AS blocking_pid,
+        blocking.query AS blocking_query,
+        EXTRACT(EPOCH FROM (NOW() - blocking.query_start))::int AS blocking_secs,
+        blocked_locks.relation::regclass::text AS table_name,
+        blocked_locks.locktype
+      FROM pg_catalog.pg_locks blocked_locks
+      JOIN pg_catalog.pg_stat_activity blocked ON blocked.pid = blocked_locks.pid
+      JOIN pg_catalog.pg_locks blocking_locks
+        ON blocking_locks.locktype = blocked_locks.locktype
+        AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation
+        AND blocking_locks.pid != blocked_locks.pid
+        AND blocking_locks.granted = true
+      JOIN pg_catalog.pg_stat_activity blocking ON blocking.pid = blocking_locks.pid
+      WHERE NOT blocked_locks.granted
+    `),
+    pool2.query(`
+      SELECT
+        pid,
+        EXTRACT(EPOCH FROM (NOW() - query_start))::int AS duration_secs,
+        query,
+        state,
+        wait_event_type
+      FROM pg_stat_activity
+      WHERE state != 'idle'
+        AND query_start IS NOT NULL
+        AND EXTRACT(EPOCH FROM (NOW() - query_start)) > 5
+        AND query NOT LIKE '%pg_stat_activity%'
+      ORDER BY duration_secs DESC
+      LIMIT 20
+    `)
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const waitingLocks = [];
+  for (const row of locksResult.rows) {
+    const key = `${row.blocked_pid}:${row.blocking_pid}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      waitingLocks.push({
+        blockedPid: parseInt(row.blocked_pid, 10),
+        blockedQuery: row.blocked_query,
+        blockedDuration: formatDurationSecs(parseInt(row.blocked_secs, 10) || 0),
+        blockingPid: parseInt(row.blocking_pid, 10),
+        blockingQuery: row.blocking_query,
+        blockingDuration: formatDurationSecs(parseInt(row.blocking_secs, 10) || 0),
+        table: row.table_name ?? null,
+        lockType: row.locktype
+      });
+    }
+  }
+  const longRunningQueries = longResult.rows.map((row) => ({
+    pid: parseInt(row.pid, 10),
+    duration: formatDurationSecs(parseInt(row.duration_secs, 10) || 0),
+    query: row.query,
+    state: row.state,
+    waitEventType: row.wait_event_type ?? null
+  }));
+  return {
+    waitingLocks,
+    longRunningQueries,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/server/config-checker.ts
+function settingToBytes(value, unit) {
+  const v = parseFloat(value);
+  if (!unit) return v;
+  switch (unit.toLowerCase()) {
+    case "b":
+      return v;
+    case "kb":
+      return v * 1024;
+    case "8kb":
+      return v * 8 * 1024;
+    // shared_buffers, effective_cache_size
+    case "mb":
+      return v * 1024 * 1024;
+    case "gb":
+      return v * 1024 * 1024 * 1024;
+    default:
+      return v;
+  }
+}
+function settingToMb(value, unit) {
+  return settingToBytes(value, unit) / (1024 * 1024);
+}
+function formatMemSetting(rawValue, unit) {
+  if (!rawValue) return "unknown";
+  const bytes = settingToBytes(rawValue, unit ?? "");
+  if (bytes <= 0 || isNaN(bytes)) return rawValue;
+  if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)}GB`;
+  if (bytes >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)}MB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)}KB`;
+  return `${bytes}B`;
+}
+async function getConfigReport(pool2) {
+  const result = await pool2.query(`
+    SELECT name, setting, unit
+    FROM pg_settings
+    WHERE name IN (
+      'max_connections', 'shared_buffers', 'work_mem',
+      'effective_cache_size', 'maintenance_work_mem', 'wal_buffers',
+      'checkpoint_completion_target', 'random_page_cost',
+      'autovacuum_vacuum_scale_factor', 'autovacuum_analyze_scale_factor',
+      'log_min_duration_statement', 'idle_in_transaction_session_timeout',
+      'effective_io_concurrency'
+    )
+  `);
+  const settings = {};
+  for (const row of result.rows) {
+    settings[row.name] = { setting: row.setting, unit: row.unit ?? void 0 };
+  }
+  const recommendations = [];
+  const get = (name) => settings[name]?.setting ?? null;
+  const getUnit = (name) => settings[name]?.unit;
+  const sharedBuffersSetting = get("shared_buffers");
+  if (sharedBuffersSetting !== null) {
+    const mb = settingToMb(sharedBuffersSetting, getUnit("shared_buffers"));
+    if (mb < 128) {
+      recommendations.push({
+        setting: "shared_buffers",
+        currentValue: `${Math.round(mb)}MB`,
+        recommendedValue: "256MB",
+        reason: "shared_buffers should be at least 25% of RAM; typical starting point is 256MB\u20131GB",
+        severity: "warning",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-SHARED-BUFFERS"
+      });
+    }
+  }
+  const workMemSetting = get("work_mem");
+  if (workMemSetting !== null) {
+    const mb = settingToMb(workMemSetting, getUnit("work_mem"));
+    if (mb <= 4) {
+      recommendations.push({
+        setting: "work_mem",
+        currentValue: `${mb % 1 === 0 ? mb : mb.toFixed(1)}MB`,
+        recommendedValue: "16MB",
+        reason: "work_mem of 4MB is conservative; consider 16MB\u201364MB for analytical queries (but multiply by max_connections for total)",
+        severity: "info",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-WORK-MEM"
+      });
+    }
+  }
+  const cctSetting = get("checkpoint_completion_target");
+  if (cctSetting !== null) {
+    const v = parseFloat(cctSetting);
+    if (v < 0.9) {
+      recommendations.push({
+        setting: "checkpoint_completion_target",
+        currentValue: cctSetting,
+        recommendedValue: "0.9",
+        reason: "Set to 0.9 to spread checkpoint I/O over 90% of checkpoint interval",
+        severity: "warning",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-CHECKPOINT-COMPLETION-TARGET"
+      });
+    }
+  }
+  const rpcSetting = get("random_page_cost");
+  if (rpcSetting !== null) {
+    const v = parseFloat(rpcSetting);
+    if (v > 2) {
+      recommendations.push({
+        setting: "random_page_cost",
+        currentValue: rpcSetting,
+        recommendedValue: "1.1",
+        reason: "If using SSDs, set random_page_cost=1.1 (default 4.0 is tuned for spinning disks)",
+        severity: "info",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-RANDOM-PAGE-COST"
+      });
+    }
+  }
+  const avsfSetting = get("autovacuum_vacuum_scale_factor");
+  if (avsfSetting !== null) {
+    const v = parseFloat(avsfSetting);
+    if (v >= 0.2) {
+      recommendations.push({
+        setting: "autovacuum_vacuum_scale_factor",
+        currentValue: avsfSetting,
+        recommendedValue: "0.05",
+        reason: "Consider lowering to 0.05\u20130.1 for large tables to vacuum more frequently",
+        severity: "info",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-autovacuum.html#GUC-AUTOVACUUM-VACUUM-SCALE-FACTOR"
+      });
+    }
+  }
+  const lmdsSetting = get("log_min_duration_statement");
+  if (lmdsSetting !== null && parseInt(lmdsSetting, 10) === -1) {
+    recommendations.push({
+      setting: "log_min_duration_statement",
+      currentValue: "-1",
+      recommendedValue: "1000",
+      reason: "Consider setting to 1000 (log queries > 1s) for performance monitoring",
+      severity: "info",
+      docs: "https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-MIN-DURATION-STATEMENT"
+    });
+  }
+  const iitsSetting = get("idle_in_transaction_session_timeout");
+  if (iitsSetting !== null && parseInt(iitsSetting, 10) === 0) {
+    recommendations.push({
+      setting: "idle_in_transaction_session_timeout",
+      currentValue: "0",
+      recommendedValue: "60000",
+      reason: "Set idle_in_transaction_session_timeout=60000 (60s) to prevent stuck transactions from holding locks",
+      severity: "warning",
+      docs: "https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-IDLE-IN-TRANSACTION-SESSION-TIMEOUT"
+    });
+  }
+  const eicSetting = get("effective_io_concurrency");
+  if (eicSetting !== null && parseInt(eicSetting, 10) === 1) {
+    recommendations.push({
+      setting: "effective_io_concurrency",
+      currentValue: "1",
+      recommendedValue: "200",
+      reason: "If using SSDs, set effective_io_concurrency=200 for better parallel I/O",
+      severity: "info",
+      docs: "https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-EFFECTIVE-IO-CONCURRENCY"
+    });
+  }
+  const mwmSetting = get("maintenance_work_mem");
+  if (mwmSetting !== null) {
+    const mb = settingToMb(mwmSetting, getUnit("maintenance_work_mem"));
+    if (mb <= 64) {
+      recommendations.push({
+        setting: "maintenance_work_mem",
+        currentValue: `${mb % 1 === 0 ? mb : mb.toFixed(1)}MB`,
+        recommendedValue: "256MB",
+        reason: "Consider 256MB for faster VACUUM and index builds",
+        severity: "info",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-MAINTENANCE-WORK-MEM"
+      });
+    }
+  }
+  const maxConnSetting = get("max_connections");
+  if (maxConnSetting !== null) {
+    const maxConn = parseInt(maxConnSetting, 10);
+    if (maxConn > 200) {
+      recommendations.push({
+        setting: "max_connections",
+        currentValue: String(maxConn),
+        recommendedValue: "100",
+        reason: `max_connections=${maxConn} is high. Each connection uses ~5\u201310MB RAM. Without a connection pooler (PgBouncer), this leads to memory pressure and context-switch overhead. Consider lowering to 100 and using a pooler.`,
+        severity: "warning",
+        docs: "https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-MAX-CONNECTIONS"
+      });
+    }
+  }
+  const serverInfo = {
+    maxConnections: maxConnSetting !== null ? parseInt(maxConnSetting, 10) : 0,
+    sharedBuffers: formatMemSetting(sharedBuffersSetting, getUnit("shared_buffers")),
+    workMem: formatMemSetting(workMemSetting, getUnit("work_mem")),
+    effectiveCacheSize: formatMemSetting(get("effective_cache_size"), getUnit("effective_cache_size")),
+    maintenanceWorkMem: formatMemSetting(mwmSetting, getUnit("maintenance_work_mem")),
+    walBuffers: get("wal_buffers") ?? "",
+    checkpointCompletionTarget: cctSetting ?? "",
+    randomPageCost: rpcSetting ?? "",
+    autovacuumVacuumScaleFactor: avsfSetting ?? ""
+  };
+  return {
+    recommendations,
+    serverInfo,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/mcp.ts
 import Database2 from "better-sqlite3";
 import path3 from "path";
@@ -2253,6 +2727,46 @@ server.tool(
     }
   }
 );
+server.tool("pg_dash_unused_indexes", "Find unused indexes that waste space and slow down writes", {}, async () => {
+  try {
+    const report = await getUnusedIndexes(pool);
+    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_bloat", "Detect table bloat (dead tuples) that slow down queries", {}, async () => {
+  try {
+    const report = await getBloatReport(pool);
+    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_autovacuum", "Check autovacuum health \u2014 which tables are stale or never vacuumed", {}, async () => {
+  try {
+    const report = await getAutovacuumReport(pool);
+    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_locks", "Show active lock waits and long-running queries blocking the database", {}, async () => {
+  try {
+    const report = await getLockReport(pool);
+    return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+server.tool("pg_dash_config_check", "Audit PostgreSQL configuration settings and get tuning recommendations", {}, async () => {
+  try {
+    const report = await getConfigReport(pool);
+    return { content: [{ type: "text", text: JSON.stringify(report, 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