@indiekitai/pg-dash 0.3.8 → 0.4.0

package/dist/mcp.js

@@ -1187,7 +1187,7 @@ async function fetchColumns(pool2) {
 }
 async function fetchIndexes(pool2) {
   const res = await pool2.query(`
-    SELECT tablename, indexname
+    SELECT tablename, indexname, indexdef
     FROM pg_indexes
     WHERE schemaname = 'public' AND indexname NOT LIKE '%_pkey'
     ORDER BY tablename, indexname
@@ -1228,6 +1228,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
     const missingColumns = [];
     const extraColumns = [];
     const typeDiffs = [];
+    const nullableDiffs = [];
+    const defaultDiffs = [];
     for (const [colName, srcInfo] of srcMap) {
       if (!tgtMap.has(colName)) {
         missingColumns.push(srcInfo);
@@ -1236,6 +1238,12 @@ function diffColumns(sourceCols, targetCols, commonTables) {
         if (srcInfo.type !== tgtInfo.type) {
           typeDiffs.push({ column: colName, sourceType: srcInfo.type, targetType: tgtInfo.type });
         }
+        if (srcInfo.nullable !== tgtInfo.nullable) {
+          nullableDiffs.push({ column: colName, sourceNullable: srcInfo.nullable, targetNullable: tgtInfo.nullable });
+        }
+        if ((srcInfo.default ?? null) !== (tgtInfo.default ?? null)) {
+          defaultDiffs.push({ column: colName, sourceDefault: srcInfo.default ?? null, targetDefault: tgtInfo.default ?? null });
+        }
       }
     }
     for (const [colName, tgtInfo] of tgtMap) {
@@ -1243,8 +1251,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
         extraColumns.push(tgtInfo);
       }
     }
-    if (missingColumns.length > 0 || extraColumns.length > 0 || typeDiffs.length > 0) {
-      diffs.push({ table, missingColumns, extraColumns, typeDiffs });
+    if (missingColumns.length > 0 || extraColumns.length > 0 || typeDiffs.length > 0 || nullableDiffs.length > 0 || defaultDiffs.length > 0) {
+      diffs.push({ table, missingColumns, extraColumns, typeDiffs, nullableDiffs, defaultDiffs });
     }
   }
   return diffs;
@@ -1252,8 +1260,8 @@ function diffColumns(sourceCols, targetCols, commonTables) {
 function groupIndexesByTable(indexes) {
   const map = /* @__PURE__ */ new Map();
   for (const idx of indexes) {
-    if (!map.has(idx.tablename)) map.set(idx.tablename, /* @__PURE__ */ new Set());
-    map.get(idx.tablename).add(idx.indexname);
+    if (!map.has(idx.tablename)) map.set(idx.tablename, /* @__PURE__ */ new Map());
+    map.get(idx.tablename).set(idx.indexname, idx.indexdef);
   }
   return map;
 }
@@ -1267,12 +1275,21 @@ function diffIndexes(sourceIdxs, targetIdxs, commonTables) {
   ]);
   for (const table of allTables) {
     if (!commonTables.includes(table)) continue;
-    const srcSet = srcByTable.get(table) ?? /* @__PURE__ */ new Set();
-    const tgtSet = tgtByTable.get(table) ?? /* @__PURE__ */ new Set();
-    const missingIndexes = [...srcSet].filter((i) => !tgtSet.has(i));
-    const extraIndexes = [...tgtSet].filter((i) => !srcSet.has(i));
-    if (missingIndexes.length > 0 || extraIndexes.length > 0) {
-      diffs.push({ table, missingIndexes, extraIndexes });
+    const srcMap = srcByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const tgtMap = tgtByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const missingIndexes = [...srcMap.keys()].filter((i) => !tgtMap.has(i));
+    const extraIndexes = [...tgtMap.keys()].filter((i) => !srcMap.has(i));
+    const modifiedIndexes = [];
+    for (const [name, srcDef] of srcMap) {
+      if (tgtMap.has(name)) {
+        const tgtDef = tgtMap.get(name);
+        if (srcDef !== tgtDef) {
+          modifiedIndexes.push({ name, sourceDef: srcDef, targetDef: tgtDef });
+        }
+      }
+    }
+    if (missingIndexes.length > 0 || extraIndexes.length > 0 || modifiedIndexes.length > 0) {
+      diffs.push({ table, missingIndexes, extraIndexes, modifiedIndexes });
     }
   }
   return diffs;
@@ -1280,10 +1297,10 @@ function diffIndexes(sourceIdxs, targetIdxs, commonTables) {
 function countSchemaDrifts(schema) {
   let n = schema.missingTables.length + schema.extraTables.length;
   for (const cd of schema.columnDiffs) {
-    n += cd.missingColumns.length + cd.extraColumns.length + cd.typeDiffs.length;
+    n += cd.missingColumns.length + cd.extraColumns.length + cd.typeDiffs.length + cd.nullableDiffs.length + cd.defaultDiffs.length;
   }
   for (const id of schema.indexDiffs) {
-    n += id.missingIndexes.length + id.extraIndexes.length;
+    n += id.missingIndexes.length + id.extraIndexes.length + id.modifiedIndexes.length;
   }
   n += (schema.constraintDiffs ?? []).length;
   n += (schema.enumDiffs ?? []).length;
@@ -1480,12 +1497,23 @@ async function analyzeExplainPlan(explainJson, pool2) {
     if (pool2) {
       existingIndexCols = await getExistingIndexColumns(pool2, scan.table);
     }
-    for (const col of cols) {
-      const alreadyCovered = existingIndexCols.some(
-        (idxCols) => idxCols.length > 0 && idxCols[0] === col
-      );
-      if (alreadyCovered) continue;
-      const benefit = rateBenefit(scan.rowCount);
+    const uncoveredCols = cols.filter(
+      (col) => !existingIndexCols.some((idxCols) => idxCols.length > 0 && idxCols[0] === col)
+    );
+    if (uncoveredCols.length === 0) continue;
+    const benefit = rateBenefit(scan.rowCount);
+    if (uncoveredCols.length >= 2) {
+      const idxName = `idx_${scan.table}_${uncoveredCols.join("_")}`;
+      const sql = `CREATE INDEX CONCURRENTLY ${idxName} ON ${scan.table} (${uncoveredCols.join(", ")})`;
+      result.missingIndexes.push({
+        table: scan.table,
+        columns: uncoveredCols,
+        reason: `Seq Scan with multi-column filter (${uncoveredCols.join(", ")}) on ${fmtRows(scan.rowCount)} rows \u2014 composite index preferred`,
+        sql,
+        estimatedBenefit: benefit
+      });
+    } else {
+      const col = uncoveredCols[0];
       const idxName = `idx_${scan.table}_${col}`;
       const sql = `CREATE INDEX CONCURRENTLY ${idxName} ON ${scan.table} (${col})`;
       result.missingIndexes.push({
@@ -1699,6 +1727,33 @@ function staticCheck(sql) {
       tableName: table
     });
   }
+  const renameTableRe = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)\s+RENAME\s+TO\s+(\w+)/gi;
+  while ((m = renameTableRe.exec(sql)) !== null) {
+    const oldName = m[1];
+    const newName = m[2];
+    issues.push({
+      severity: "warning",
+      code: "RENAME_TABLE",
+      message: `Renaming table "${oldName}" to "${newName}" breaks application code referencing the old name`,
+      suggestion: "Deploy application code that handles both names before renaming, or use a view with the old name after renaming.",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: oldName
+    });
+  }
+  const renameColumnRe = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(\w+)\s+RENAME\s+COLUMN\s+(\w+)\s+TO\s+(\w+)/gi;
+  while ((m = renameColumnRe.exec(sql)) !== null) {
+    const table = m[1];
+    const oldCol = m[2];
+    const newCol = m[3];
+    issues.push({
+      severity: "warning",
+      code: "RENAME_COLUMN",
+      message: `Renaming column "${oldCol}" to "${newCol}" on table "${table}" breaks application code referencing the old column name`,
+      suggestion: "Add new column, backfill data, update application to use new column, then drop old column (expand/contract pattern).",
+      lineNumber: findLineNumber(sql, m.index),
+      tableName: table
+    });
+  }
   const addConRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ADD\s+CONSTRAINT\b[^;]*(;|$)/gi;
   while ((m = addConRe.exec(sql)) !== null) {
     const fragment = m[0];
@@ -1847,6 +1902,456 @@ 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 indexes = indexResult.rows.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: "4MB",
+        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: "64MB",
+        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");
+  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";
@@ -2198,6 +2703,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