@indiekitai/pg-dash 0.3.4 → 0.3.6

package/dist/mcp.js

@@ -1,10 +1,9 @@
 #!/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 { Pool as Pool2 } from "pg";
 import { z } from "zod";
 
 // src/server/queries/overview.ts
@@ -954,27 +953,28 @@ async function getSlowQueries(pool2) {
 // src/server/snapshot.ts
 import fs2 from "fs";
 import path2 from "path";
-var SNAPSHOT_FILE = "last-check.json";
-function saveSnapshot(dataDir2, result) {
-  fs2.mkdirSync(dataDir2, { recursive: true });
+function normalizeIssueId(id) {
+  return id.replace(/-\d+$/, "");
+}
+function saveSnapshot(snapshotPath, result) {
+  fs2.mkdirSync(path2.dirname(snapshotPath), { recursive: true });
   const snapshot = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), result };
-  fs2.writeFileSync(path2.join(dataDir2, SNAPSHOT_FILE), JSON.stringify(snapshot, null, 2));
+  fs2.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
 }
-function loadSnapshot(dataDir2) {
-  const filePath = path2.join(dataDir2, SNAPSHOT_FILE);
-  if (!fs2.existsSync(filePath)) return null;
+function loadSnapshot(snapshotPath) {
+  if (!fs2.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs2.readFileSync(snapshotPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function diffSnapshots(prev, current) {
-  const prevIds = new Set(prev.issues.map((i) => i.id));
-  const currIds = new Set(current.issues.map((i) => i.id));
-  const newIssues = current.issues.filter((i) => !prevIds.has(i.id));
-  const resolvedIssues = prev.issues.filter((i) => !currIds.has(i.id));
-  const unchanged = current.issues.filter((i) => prevIds.has(i.id));
+  const prevNormIds = new Set(prev.issues.map((i) => normalizeIssueId(i.id)));
+  const currNormIds = new Set(current.issues.map((i) => normalizeIssueId(i.id)));
+  const newIssues = current.issues.filter((i) => !prevNormIds.has(normalizeIssueId(i.id)));
+  const resolvedIssues = prev.issues.filter((i) => !currNormIds.has(normalizeIssueId(i.id)));
+  const unchanged = current.issues.filter((i) => prevNormIds.has(normalizeIssueId(i.id)));
   return {
     scoreDelta: current.score - prev.score,
     previousScore: prev.score,
@@ -987,6 +987,612 @@ function diffSnapshots(prev, current) {
   };
 }
 
+// src/server/env-differ.ts
+import { Pool } from "pg";
+async function fetchTables(pool2) {
+  const res = await pool2.query(`
+    SELECT table_name
+    FROM information_schema.tables
+    WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+    ORDER BY table_name
+  `);
+  return res.rows.map((r) => r.table_name);
+}
+async function fetchColumns(pool2) {
+  const res = await pool2.query(`
+    SELECT table_name, column_name, data_type, is_nullable, column_default
+    FROM information_schema.columns
+    WHERE table_schema = 'public'
+    ORDER BY table_name, ordinal_position
+  `);
+  return res.rows;
+}
+async function fetchIndexes(pool2) {
+  const res = await pool2.query(`
+    SELECT tablename, indexname
+    FROM pg_indexes
+    WHERE schemaname = 'public' AND indexname NOT LIKE '%_pkey'
+    ORDER BY tablename, indexname
+  `);
+  return res.rows;
+}
+function diffTables(sourceTables, targetTables) {
+  const sourceSet = new Set(sourceTables);
+  const targetSet = new Set(targetTables);
+  return {
+    missingTables: sourceTables.filter((t) => !targetSet.has(t)),
+    extraTables: targetTables.filter((t) => !sourceSet.has(t))
+  };
+}
+function groupColumnsByTable(columns) {
+  const map = /* @__PURE__ */ new Map();
+  for (const col of columns) {
+    if (!map.has(col.table_name)) map.set(col.table_name, /* @__PURE__ */ new Map());
+    const info = {
+      name: col.column_name,
+      type: col.data_type,
+      nullable: col.is_nullable === "YES"
+    };
+    if (col.column_default !== null && col.column_default !== void 0) {
+      info.default = col.column_default;
+    }
+    map.get(col.table_name).set(col.column_name, info);
+  }
+  return map;
+}
+function diffColumns(sourceCols, targetCols, commonTables) {
+  const sourceByTable = groupColumnsByTable(sourceCols);
+  const targetByTable = groupColumnsByTable(targetCols);
+  const diffs = [];
+  for (const table of commonTables) {
+    const srcMap = sourceByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const tgtMap = targetByTable.get(table) ?? /* @__PURE__ */ new Map();
+    const missingColumns = [];
+    const extraColumns = [];
+    const typeDiffs = [];
+    for (const [colName, srcInfo] of srcMap) {
+      if (!tgtMap.has(colName)) {
+        missingColumns.push(srcInfo);
+      } else {
+        const tgtInfo = tgtMap.get(colName);
+        if (srcInfo.type !== tgtInfo.type) {
+          typeDiffs.push({ column: colName, sourceType: srcInfo.type, targetType: tgtInfo.type });
+        }
+      }
+    }
+    for (const [colName, tgtInfo] of tgtMap) {
+      if (!srcMap.has(colName)) {
+        extraColumns.push(tgtInfo);
+      }
+    }
+    if (missingColumns.length > 0 || extraColumns.length > 0 || typeDiffs.length > 0) {
+      diffs.push({ table, missingColumns, extraColumns, typeDiffs });
+    }
+  }
+  return diffs;
+}
+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);
+  }
+  return map;
+}
+function diffIndexes(sourceIdxs, targetIdxs, commonTables) {
+  const srcByTable = groupIndexesByTable(sourceIdxs);
+  const tgtByTable = groupIndexesByTable(targetIdxs);
+  const diffs = [];
+  const allTables = /* @__PURE__ */ new Set([
+    ...sourceIdxs.map((i) => i.tablename),
+    ...targetIdxs.map((i) => i.tablename)
+  ]);
+  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 });
+    }
+  }
+  return diffs;
+}
+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;
+  }
+  for (const id of schema.indexDiffs) {
+    n += id.missingIndexes.length + id.extraIndexes.length;
+  }
+  return n;
+}
+async function diffEnvironments(sourceConn, targetConn, options) {
+  const sourcePool = new Pool({ connectionString: sourceConn, connectionTimeoutMillis: 1e4 });
+  const targetPool = new Pool({ connectionString: targetConn, connectionTimeoutMillis: 1e4 });
+  try {
+    const [
+      sourceTables,
+      targetTables,
+      sourceCols,
+      targetCols,
+      sourceIdxs,
+      targetIdxs
+    ] = await Promise.all([
+      fetchTables(sourcePool),
+      fetchTables(targetPool),
+      fetchColumns(sourcePool),
+      fetchColumns(targetPool),
+      fetchIndexes(sourcePool),
+      fetchIndexes(targetPool)
+    ]);
+    const { missingTables, extraTables } = diffTables(sourceTables, targetTables);
+    const sourceSet = new Set(sourceTables);
+    const targetSet = new Set(targetTables);
+    const commonTables = sourceTables.filter((t) => targetSet.has(t));
+    const columnDiffs = diffColumns(sourceCols, targetCols, commonTables);
+    const indexDiffs = diffIndexes(sourceIdxs, targetIdxs, commonTables);
+    const schema = { missingTables, extraTables, columnDiffs, indexDiffs };
+    const schemaDrifts = countSchemaDrifts(schema);
+    let health;
+    if (options?.includeHealth) {
+      const longQueryThreshold2 = 5;
+      const [srcReport, tgtReport] = await Promise.all([
+        getAdvisorReport(sourcePool, longQueryThreshold2),
+        getAdvisorReport(targetPool, longQueryThreshold2)
+      ]);
+      const srcIssueKeys = new Set(srcReport.issues.map((i) => i.title));
+      const tgtIssueKeys = new Set(tgtReport.issues.map((i) => i.title));
+      const sourceOnlyIssues = srcReport.issues.filter((i) => !tgtIssueKeys.has(i.title)).map((i) => `${i.severity}: ${i.title}`);
+      const targetOnlyIssues = tgtReport.issues.filter((i) => !srcIssueKeys.has(i.title)).map((i) => `${i.severity}: ${i.title}`);
+      health = {
+        source: { score: srcReport.score, grade: srcReport.grade, url: maskConnectionString(sourceConn) },
+        target: { score: tgtReport.score, grade: tgtReport.grade, url: maskConnectionString(targetConn) },
+        sourceOnlyIssues,
+        targetOnlyIssues
+      };
+    }
+    return {
+      schema,
+      health,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: {
+        schemaDrifts,
+        identical: schemaDrifts === 0
+      }
+    };
+  } finally {
+    await Promise.allSettled([sourcePool.end(), targetPool.end()]);
+  }
+}
+function maskConnectionString(connStr) {
+  try {
+    const url = new URL(connStr);
+    if (url.password) url.password = "***";
+    return url.toString();
+  } catch {
+    return "<redacted>";
+  }
+}
+
+// src/server/query-analyzer.ts
+function collectNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  acc.push(node);
+  const plans = node["Plans"] ?? node["plans"];
+  if (Array.isArray(plans)) {
+    for (const child of plans) collectNodes(child, acc);
+  }
+  return acc;
+}
+function extractColumnsFromFilter(filter) {
+  const colPattern = /\(?"?([a-z_][a-z0-9_]*)"?\s*(?:=|<|>|<=|>=|<>|!=|IS\s+(?:NOT\s+)?NULL|~~|!~~)/gi;
+  const found = /* @__PURE__ */ new Set();
+  let m;
+  while ((m = colPattern.exec(filter)) !== null) {
+    const col = m[1].toLowerCase();
+    if (!["and", "or", "not", "true", "false", "null"].includes(col)) {
+      found.add(col);
+    }
+  }
+  return Array.from(found);
+}
+async function getExistingIndexColumns(pool2, tableName) {
+  try {
+    const r = await pool2.query(
+      `SELECT indexdef FROM pg_indexes WHERE tablename = $1`,
+      [tableName]
+    );
+    return r.rows.map((row) => {
+      const m = /\(([^)]+)\)/.exec(row.indexdef);
+      if (!m) return [];
+      return m[1].split(",").map((c) => c.trim().replace(/^"|"$/g, "").toLowerCase());
+    });
+  } catch {
+    return [];
+  }
+}
+function rateBenefit(rowCount) {
+  if (rowCount > 1e5) return "high";
+  if (rowCount >= 1e4) return "medium";
+  return "low";
+}
+function fmtRows(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+async function analyzeExplainPlan(explainJson, pool2) {
+  const result = {
+    planNodes: [],
+    seqScans: [],
+    missingIndexes: [],
+    costEstimate: { totalCost: 0 },
+    recommendations: []
+  };
+  if (!explainJson || !Array.isArray(explainJson) || explainJson.length === 0) {
+    return result;
+  }
+  const topLevel = explainJson[0];
+  const planRoot = topLevel?.["Plan"] ?? topLevel?.["plan"];
+  const planningTime = topLevel?.["Planning Time"] ?? void 0;
+  const executionTime = topLevel?.["Execution Time"] ?? void 0;
+  if (!planRoot) return result;
+  const allNodes = collectNodes(planRoot);
+  result.planNodes = allNodes.map((n) => {
+    const s = {
+      nodeType: n["Node Type"] ?? "Unknown",
+      totalCost: n["Total Cost"] ?? 0
+    };
+    if (n["Relation Name"]) s.table = n["Relation Name"];
+    if (n["Actual Rows"] !== void 0) s.actualRows = n["Actual Rows"];
+    if (n["Actual Total Time"] !== void 0) s.actualTime = n["Actual Total Time"];
+    if (n["Filter"]) s.filter = n["Filter"];
+    return s;
+  });
+  result.costEstimate = {
+    totalCost: planRoot["Total Cost"] ?? 0,
+    actualTime: executionTime,
+    planningTime
+  };
+  const seqScanNodes = allNodes.filter((n) => n["Node Type"] === "Seq Scan");
+  for (const node of seqScanNodes) {
+    const table = node["Relation Name"] ?? "unknown";
+    const rowCount = node["Plan Rows"] ?? node["Actual Rows"] ?? 0;
+    const filter = node["Filter"];
+    const info = { table, rowCount, filter };
+    if (rowCount > 1e4) {
+      info.suggestion = filter ? `Consider adding an index to support the filter on ${table}` : `Full table scan on large table ${table} \u2014 review query`;
+    }
+    result.seqScans.push(info);
+  }
+  for (const scan of result.seqScans) {
+    if (!scan.filter) continue;
+    const cols = extractColumnsFromFilter(scan.filter);
+    if (cols.length === 0) continue;
+    let existingIndexCols = [];
+    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 idxName = `idx_${scan.table}_${col}`;
+      const sql = `CREATE INDEX CONCURRENTLY ${idxName} ON ${scan.table} (${col})`;
+      result.missingIndexes.push({
+        table: scan.table,
+        columns: [col],
+        reason: `Seq Scan with Filter on ${col} (${fmtRows(scan.rowCount)} rows)`,
+        sql,
+        estimatedBenefit: benefit
+      });
+    }
+  }
+  for (const scan of result.seqScans) {
+    if (scan.rowCount > 1e4) {
+      const filterPart = scan.filter ? ` \u2014 consider adding index on ${extractColumnsFromFilter(scan.filter).join(", ") || "filter columns"}` : " \u2014 no filter; full scan may be intentional";
+      result.recommendations.push(
+        `Seq Scan on ${scan.table} (${fmtRows(scan.rowCount)} rows)${filterPart}`
+      );
+    }
+  }
+  if (planningTime !== void 0) {
+    const label = planningTime > 10 ? "high \u2014 check statistics" : "normal";
+    result.recommendations.push(`Planning time ${planningTime.toFixed(1)}ms \u2014 ${label}`);
+  }
+  if (result.missingIndexes.length === 0 && result.seqScans.length === 0) {
+    result.recommendations.push("No obvious sequential scans detected \u2014 query looks efficient");
+  }
+  return result;
+}
+async function detectQueryRegressions(pool2, statsDb, windowHours = 24) {
+  try {
+    const extCheck = await pool2.query(
+      "SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements'"
+    );
+    if (extCheck.rows.length === 0) return [];
+    const current = await pool2.query(`
+      SELECT queryid::text AS queryid, mean_exec_time
+      FROM pg_stat_statements
+      WHERE query NOT LIKE '%pg_stat%'
+        AND queryid IS NOT NULL
+    `);
+    const currentMap = /* @__PURE__ */ new Map();
+    for (const row of current.rows) {
+      currentMap.set(row.queryid, parseFloat(row.mean_exec_time));
+    }
+    if (!statsDb) return [];
+    const windowMs = windowHours * 60 * 60 * 1e3;
+    const since = Date.now() - windowMs;
+    let historical;
+    try {
+      historical = statsDb.prepare(
+        `SELECT queryid, mean_exec_time, timestamp
+           FROM query_stats
+           WHERE timestamp >= ?
+           ORDER BY queryid, timestamp ASC`
+      ).all(since);
+    } catch {
+      return [];
+    }
+    const baselineMap = /* @__PURE__ */ new Map();
+    for (const row of historical) {
+      if (!baselineMap.has(row.queryid)) {
+        baselineMap.set(row.queryid, {
+          meanMs: row.mean_exec_time,
+          timestamp: row.timestamp
+        });
+      }
+    }
+    const regressions = [];
+    for (const [queryId, baseline] of baselineMap) {
+      const currentMean = currentMap.get(queryId);
+      if (currentMean === void 0 || baseline.meanMs === 0) continue;
+      const changePercent = (currentMean - baseline.meanMs) / baseline.meanMs * 100;
+      if (changePercent > 50) {
+        regressions.push({
+          queryId,
+          currentMeanMs: currentMean,
+          previousMeanMs: baseline.meanMs,
+          changePercent: Math.round(changePercent),
+          degradedAt: new Date(baseline.timestamp).toISOString()
+        });
+      }
+    }
+    return regressions.sort((a, b) => b.changePercent - a.changePercent);
+  } catch {
+    return [];
+  }
+}
+
+// src/server/migration-checker.ts
+function stripComments(sql) {
+  let stripped = sql.replace(
+    /\/\*[\s\S]*?\*\//g,
+    (match) => match.replace(/[^\n]/g, " ")
+  );
+  stripped = stripped.replace(/--[^\n]*/g, (match) => " ".repeat(match.length));
+  return stripped;
+}
+function findLineNumber(sql, matchIndex) {
+  const before = sql.slice(0, matchIndex);
+  return before.split("\n").length;
+}
+function bareTable(name) {
+  return name.replace(/^public\./i, "").replace(/"/g, "").toLowerCase().trim();
+}
+function extractOperatedTables(sql) {
+  sql = stripComments(sql);
+  const indexTables = [];
+  const alterTables = [];
+  const dropTables = [];
+  const refTables = [];
+  const idxRe = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?:\w+\s+)?ON\s+([\w."]+)/gi;
+  let m;
+  while ((m = idxRe.exec(sql)) !== null) indexTables.push(bareTable(m[1]));
+  const altRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)/gi;
+  while ((m = altRe.exec(sql)) !== null) alterTables.push(bareTable(m[1]));
+  const dropRe = /\bDROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)/gi;
+  while ((m = dropRe.exec(sql)) !== null) dropTables.push(bareTable(m[1]));
+  const refRe = /\bREFERENCES\s+([\w."]+)/gi;
+  while ((m = refRe.exec(sql)) !== null) refTables.push(bareTable(m[1]));
+  return { indexTables, alterTables, dropTables, refTables };
+}
+function staticCheck(sql) {
+  const issues = [];
+  sql = stripComments(sql);
+  const createdTablesRe = /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([\w."]+)/gi;
+  const createdTables = /* @__PURE__ */ new Set();
+  let m;
+  while ((m = createdTablesRe.exec(sql)) !== null) createdTables.add(bareTable(m[1]));
+  const idxRe = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+(?!CONCURRENTLY)((?:IF\s+NOT\s+EXISTS\s+)?(?:\w+\s+)?ON\s+([\w."]+))/gi;
+  while ((m = idxRe.exec(sql)) !== null) {
+    const table = bareTable(m[2]);
+    const lineNumber = findLineNumber(sql, m.index);
+    if (!createdTables.has(table)) {
+      issues.push({
+        severity: "warning",
+        code: "INDEX_WITHOUT_CONCURRENTLY",
+        message: `CREATE INDEX on existing table will lock writes. Use CREATE INDEX CONCURRENTLY to avoid downtime.`,
+        suggestion: "Replace CREATE INDEX with CREATE INDEX CONCURRENTLY",
+        lineNumber,
+        tableName: table
+      });
+    }
+  }
+  const idxConcRe = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\b/gi;
+  while ((m = idxConcRe.exec(sql)) !== null) {
+    issues.push({
+      severity: "info",
+      code: "INDEX_CONCURRENTLY_OK",
+      message: "CREATE INDEX CONCURRENTLY \u2014 safe, no write lock",
+      lineNumber: findLineNumber(sql, m.index)
+    });
+  }
+  const addColRe = /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([\w."]+)\s+ADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?[\w"]+\s+[\w\s()"',.[\]]+?(?=;|$)/gi;
+  while ((m = addColRe.exec(sql)) !== null) {
+    const fragment = m[0];
+    const table = bareTable(m[1]);
+    const lineNumber = findLineNumber(sql, m.index);
+    const fragUpper = fragment.toUpperCase();
+    const hasNotNull = /\bNOT\s+NULL\b/.test(fragUpper);
+    const hasDefault = /\bDEFAULT\b/.test(fragUpper);
+    if (hasNotNull && !hasDefault) {
+      issues.push({
+        severity: "error",
+        code: "ADD_COLUMN_NOT_NULL_NO_DEFAULT",
+        message: "ADD COLUMN NOT NULL without DEFAULT will fail if table has existing rows",
+        suggestion: "Add a DEFAULT value, then remove it after migration",
+        lineNumber,
+        tableName: table
+      });
+    } else if (hasNotNull && hasDefault) {
+      issues.push({
+        severity: "warning",
+        code: "ADD_COLUMN_REWRITES_TABLE",
+        message: "ADD COLUMN with NOT NULL DEFAULT may rewrite table on PostgreSQL < 11",
+        suggestion: "On PostgreSQL 11+ with a constant default this is safe. For older versions, add column nullable first.",
+        lineNumber,
+        tableName: table
+      });
+    }
+  }
+  const dropRe = /\bDROP\s+TABLE\b/gi;
+  while ((m = dropRe.exec(sql)) !== null) {
+    issues.push({
+      severity: "warning",
+      code: "DROP_TABLE",
+      message: "DROP TABLE is destructive. Ensure this is intentional and data is backed up.",
+      lineNumber: findLineNumber(sql, m.index)
+    });
+  }
+  const truncRe = /\bTRUNCATE\b/gi;
+  while ((m = truncRe.exec(sql)) !== null) {
+    issues.push({
+      severity: "warning",
+      code: "TRUNCATE_TABLE",
+      message: "TRUNCATE will delete all rows. Ensure this is intentional.",
+      lineNumber: findLineNumber(sql, m.index)
+    });
+  }
+  const delRe = /\bDELETE\s+FROM\s+[\w."]+\s*(?:;|$)/gi;
+  while ((m = delRe.exec(sql)) !== null) {
+    const stmt = m[0];
+    if (!/\bWHERE\b/i.test(stmt)) {
+      issues.push({
+        severity: "warning",
+        code: "DELETE_WITHOUT_WHERE",
+        message: "DELETE without WHERE clause will remove all rows.",
+        lineNumber: findLineNumber(sql, m.index)
+      });
+    }
+  }
+  const updRe = /\bUPDATE\s+[\w."]+\s+SET\b[^;]*(;|$)/gi;
+  while ((m = updRe.exec(sql)) !== null) {
+    const stmt = m[0];
+    if (!/\bWHERE\b/i.test(stmt)) {
+      issues.push({
+        severity: "warning",
+        code: "UPDATE_WITHOUT_WHERE",
+        message: "UPDATE without WHERE clause will modify all rows.",
+        lineNumber: findLineNumber(sql, m.index)
+      });
+    }
+  }
+  return issues;
+}
+async function dynamicCheck(sql, pool2, staticIssues) {
+  const issues = [];
+  const { indexTables, alterTables, dropTables, refTables } = extractOperatedTables(sql);
+  const allTables = [.../* @__PURE__ */ new Set([...indexTables, ...alterTables, ...dropTables])];
+  const tableStats = /* @__PURE__ */ new Map();
+  if (allTables.length > 0) {
+    try {
+      const res = await pool2.query(
+        `SELECT tablename,
+                n_live_tup,
+                pg_total_relation_size(schemaname||'.'||tablename) AS total_size
+         FROM pg_stat_user_tables
+         WHERE tablename = ANY($1)`,
+        [allTables]
+      );
+      for (const row of res.rows) {
+        tableStats.set(row.tablename, {
+          rowCount: parseInt(row.n_live_tup ?? "0", 10),
+          totalSize: parseInt(row.total_size ?? "0", 10)
+        });
+      }
+    } catch (_) {
+    }
+  }
+  for (const issue of staticIssues) {
+    if (issue.code === "INDEX_WITHOUT_CONCURRENTLY" && issue.tableName) {
+      const stats = tableStats.get(issue.tableName);
+      if (stats) {
+        const { rowCount } = stats;
+        const lockSecs = Math.round(rowCount / 5e4);
+        issue.estimatedRows = rowCount;
+        issue.estimatedLockSeconds = lockSecs;
+        if (rowCount > 1e6) {
+          issue.severity = "error";
+          issue.message = `CREATE INDEX on '${issue.tableName}' will lock writes for ~${lockSecs}s (${(rowCount / 1e6).toFixed(1)}M rows). CRITICAL \u2014 use CREATE INDEX CONCURRENTLY.`;
+        } else if (rowCount > 1e5) {
+          issue.message = `CREATE INDEX on '${issue.tableName}' will lock writes for ~${lockSecs}s (${(rowCount / 1e3).toFixed(0)}k rows).`;
+        }
+      }
+    }
+  }
+  const uniqueRefTables = [...new Set(refTables)];
+  for (const table of uniqueRefTables) {
+    try {
+      const res = await pool2.query(
+        `SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename = $1`,
+        [table]
+      );
+      if (res.rows.length === 0) {
+        issues.push({
+          severity: "error",
+          code: "MISSING_TABLE",
+          message: `Table '${table}' referenced in migration does not exist`,
+          tableName: table
+        });
+      }
+    } catch (_) {
+    }
+  }
+  return issues;
+}
+async function analyzeMigration(sql, pool2) {
+  const trimmed = sql.trim();
+  if (!trimmed) {
+    return {
+      safe: true,
+      issues: [],
+      summary: { errors: 0, warnings: 0, infos: 0 },
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const issues = staticCheck(trimmed);
+  if (pool2) {
+    const dynamicIssues = await dynamicCheck(trimmed, pool2, issues);
+    issues.push(...dynamicIssues);
+  }
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  const infos = issues.filter((i) => i.severity === "info").length;
+  return {
+    safe: errors === 0,
+    issues,
+    summary: { errors, warnings, infos },
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/mcp.ts
 import Database2 from "better-sqlite3";
 import path3 from "path";
@@ -999,7 +1605,7 @@ if (!connString) {
   console.error("  or set PG_DASH_CONNECTION_STRING env var");
   process.exit(1);
 }
-var pool = new Pool({ connectionString: connString });
+var pool = new Pool2({ connectionString: connString, connectionTimeoutMillis: 1e4 });
 var longQueryThreshold = parseInt(process.env.PG_DASH_LONG_QUERY_THRESHOLD || "5", 10);
 var dataDir = process.env.PG_DASH_DATA_DIR || path3.join(os2.homedir(), ".pg-dash");
 fs3.mkdirSync(dataDir, { recursive: true });
@@ -1017,6 +1623,13 @@ try {
 } catch (err) {
   console.error("[mcp] Error:", err.message);
 }
+var queryStatsDb = null;
+try {
+  const queryStatsPath = path3.join(dataDir, "query-stats.db");
+  if (fs3.existsSync(queryStatsPath)) queryStatsDb = new Database2(queryStatsPath, { readonly: true });
+} catch (err) {
+  console.error("[mcp] Error:", err.message);
+}
 var server = new McpServer({ name: "pg-dash", version: pkg.version });
 server.tool("pg_dash_overview", "Get database overview (version, uptime, size, connections)", {}, async () => {
   try {
@@ -1226,19 +1839,111 @@ ${fix.sql}
 });
 server.tool("pg_dash_diff", "Compare current health with last saved snapshot", {}, async () => {
   try {
-    const prev = loadSnapshot(dataDir);
+    const snapshotPath = path3.join(dataDir, "last-check.json");
+    const prev = loadSnapshot(snapshotPath);
     const current = await getAdvisorReport(pool, longQueryThreshold);
     if (!prev) {
-      saveSnapshot(dataDir, current);
+      saveSnapshot(snapshotPath, current);
       return { content: [{ type: "text", text: JSON.stringify({ message: "No previous snapshot found. Current result saved as baseline.", score: current.score, grade: current.grade, issues: current.issues.length }, null, 2) }] };
     }
     const diff = diffSnapshots(prev.result, current);
-    saveSnapshot(dataDir, current);
+    saveSnapshot(snapshotPath, current);
     return { content: [{ type: "text", text: JSON.stringify({ ...diff, previousTimestamp: prev.timestamp }, null, 2) }] };
   } catch (err) {
     return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
   }
 });
+server.tool(
+  "pg_dash_check_migration",
+  "Analyze migration SQL for safety risks (lock tables, missing tables, destructive ops)",
+  {
+    sql: z.string().describe("Migration SQL content to analyze")
+  },
+  async ({ sql }) => {
+    try {
+      const result = await analyzeMigration(sql, pool);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.tool(
+  "pg_dash_analyze_query",
+  "Deep analysis of a SQL query: runs EXPLAIN ANALYZE, detects missing indexes, and provides specific optimization recommendations",
+  {
+    sql: z.string().describe("SELECT query to analyze")
+  },
+  async ({ sql }) => {
+    try {
+      if (!/^\s*SELECT\b/i.test(sql)) {
+        return { content: [{ type: "text", text: "Error: Only SELECT queries are allowed" }], isError: true };
+      }
+      const client = await pool.connect();
+      try {
+        await client.query("SET statement_timeout = '30s'");
+        await client.query("BEGIN");
+        try {
+          const r = await client.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${sql}`);
+          await client.query("ROLLBACK");
+          await client.query("RESET statement_timeout");
+          const plan = r.rows[0]["QUERY PLAN"];
+          const analysis = await analyzeExplainPlan(plan, pool);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ plan, analysis }, null, 2)
+            }]
+          };
+        } catch (err) {
+          await client.query("ROLLBACK").catch(() => {
+          });
+          await client.query("RESET statement_timeout").catch(() => {
+          });
+          return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+        }
+      } finally {
+        client.release();
+      }
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.tool(
+  "pg_dash_query_regressions",
+  "Detect queries that have gotten significantly slower (>50% degradation) compared to historical baselines",
+  {
+    windowHours: z.number().optional().describe("Hours to look back (default: 24)")
+  },
+  async ({ windowHours }) => {
+    try {
+      const regressions = await detectQueryRegressions(pool, queryStatsDb, windowHours ?? 24);
+      if (regressions.length === 0) {
+        return { content: [{ type: "text", text: "No query regressions detected in the specified window." }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(regressions, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+server.tool(
+  "pg_dash_compare_env",
+  "Compare schema and health between two PostgreSQL environments. Detects missing tables, columns, indexes.",
+  {
+    targetUrl: z.string().describe("Target database connection string to compare against"),
+    includeHealth: z.boolean().optional().describe("Also compare health scores and issues")
+  },
+  async ({ targetUrl, includeHealth }) => {
+    try {
+      const result = await diffEnvironments(connString, targetUrl, { includeHealth: includeHealth ?? false });
+      return { content: [{ type: "text", text: JSON.stringify(result, 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