@indiekitai/pg-dash 0.3.2 → 0.3.4

package/dist/cli.js

@@ -661,6 +661,28 @@ SELECT pg_reload_conf();`,
     const ignoredSet = new Set(ignoredIds);
     const activeIssues = issues.filter((i) => !ignoredSet.has(i.id));
     const ignoredCount = issues.length - activeIssues.length;
+    const batchFixes = [];
+    const groups = /* @__PURE__ */ new Map();
+    for (const issue of activeIssues) {
+      const prefix = issue.id.replace(/-[^-]+$/, "");
+      if (!groups.has(prefix)) groups.set(prefix, []);
+      groups.get(prefix).push(issue);
+    }
+    const BATCH_TITLES = {
+      "schema-fk-no-idx": "Create all missing FK indexes",
+      "schema-unused-idx": "Drop all unused indexes",
+      "schema-no-pk": "Fix all tables missing primary keys",
+      "maint-vacuum": "VACUUM all overdue tables",
+      "maint-analyze": "ANALYZE all tables missing statistics",
+      "perf-bloated-idx": "REINDEX all bloated indexes",
+      "perf-bloat": "VACUUM FULL all bloated tables"
+    };
+    for (const [prefix, group] of groups) {
+      if (group.length <= 1) continue;
+      const title = BATCH_TITLES[prefix] || `Fix all ${group.length} ${prefix} issues`;
+      const sql = group.map((i) => i.fix.split("\n").filter((l) => !l.trim().startsWith("--")).join("\n").trim()).filter(Boolean).join(";\n") + ";";
+      batchFixes.push({ type: prefix, title: `${title} (${group.length})`, count: group.length, sql });
+    }
     const score = computeAdvisorScore(activeIssues);
     return {
       score,
@@ -668,7 +690,8 @@ SELECT pg_reload_conf();`,
       issues: activeIssues,
       breakdown: computeBreakdown(activeIssues),
       skipped,
-      ignoredCount
+      ignoredCount,
+      batchFixes
     };
   } finally {
     client.release();
@@ -731,6 +754,54 @@ var init_advisor = __esm({
   }
 });
 
+// src/server/snapshot.ts
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  diffSnapshots: () => diffSnapshots2,
+  loadSnapshot: () => loadSnapshot,
+  saveSnapshot: () => saveSnapshot
+});
+import fs4 from "fs";
+import path4 from "path";
+function saveSnapshot(dataDir, result) {
+  fs4.mkdirSync(dataDir, { recursive: true });
+  const snapshot = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), result };
+  fs4.writeFileSync(path4.join(dataDir, SNAPSHOT_FILE), JSON.stringify(snapshot, null, 2));
+}
+function loadSnapshot(dataDir) {
+  const filePath = path4.join(dataDir, SNAPSHOT_FILE);
+  if (!fs4.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function diffSnapshots2(prev, current) {
+  const prevIds = new Set(prev.issues.map((i) => i.id));
+  const currIds = new Set(current.issues.map((i) => i.id));
+  const newIssues = current.issues.filter((i) => !prevIds.has(i.id));
+  const resolvedIssues = prev.issues.filter((i) => !currIds.has(i.id));
+  const unchanged = current.issues.filter((i) => prevIds.has(i.id));
+  return {
+    scoreDelta: current.score - prev.score,
+    previousScore: prev.score,
+    currentScore: current.score,
+    previousGrade: prev.grade,
+    currentGrade: current.grade,
+    newIssues,
+    resolvedIssues,
+    unchanged
+  };
+}
+var SNAPSHOT_FILE;
+var init_snapshot = __esm({
+  "src/server/snapshot.ts"() {
+    "use strict";
+    SNAPSHOT_FILE = "last-check.json";
+  }
+});
+
 // src/cli.ts
 import { parseArgs } from "util";
 
@@ -943,6 +1014,7 @@ var Collector = class extends EventEmitter {
   pruneTimer = null;
   prev = null;
   lastSnapshot = {};
+  collectCount = 0;
   start() {
     this.collect().catch((err) => console.error("[collector] Initial collection failed:", err));
     this.timer = setInterval(() => {
@@ -1045,6 +1117,28 @@ var Collector = class extends EventEmitter {
       console.error("[collector] Error collecting metrics:", err.message);
       return snapshot;
     }
+    this.collectCount++;
+    if (this.collectCount % 10 === 0) {
+      try {
+        const client = await this.pool.connect();
+        try {
+          const tableRes = await client.query(`
+            SELECT schemaname, relname,
+                   pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) as total_size
+            FROM pg_stat_user_tables
+            ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
+            LIMIT 20
+          `);
+          for (const row of tableRes.rows) {
+            this.store.insert(`table_size:${row.schemaname}.${row.relname}`, parseInt(row.total_size), now);
+          }
+        } finally {
+          client.release();
+        }
+      } catch (err) {
+        console.error("[collector] Error collecting table sizes:", err.message);
+      }
+    }
     const points = Object.entries(snapshot).map(([metric, value]) => ({
       timestamp: now,
       metric,
@@ -1896,7 +1990,12 @@ function registerActivityRoutes(app, pool) {
 
 // src/server/routes/advisor.ts
 init_advisor();
-function registerAdvisorRoutes(app, pool, longQueryThreshold) {
+var RANGE_MAP2 = {
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3
+};
+function registerAdvisorRoutes(app, pool, longQueryThreshold, store) {
   app.get("/api/advisor", async (c) => {
     try {
       return c.json(await getAdvisorReport(pool, longQueryThreshold));
@@ -1931,6 +2030,18 @@ function registerAdvisorRoutes(app, pool, longQueryThreshold) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/advisor/history", (c) => {
+    if (!store) return c.json([]);
+    try {
+      const range = c.req.query("range") || "24h";
+      const rangeMs = RANGE_MAP2[range] || RANGE_MAP2["24h"];
+      const now = Date.now();
+      const data = store.query("health_score", now - rangeMs, now);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
   app.post("/api/fix", async (c) => {
     try {
       const body = await c.req.json();
@@ -2214,7 +2325,7 @@ var DiskPredictor = class {
 };
 
 // src/server/routes/disk.ts
-var RANGE_MAP2 = {
+var RANGE_MAP3 = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
   "30d": 30 * 24 * 60 * 60 * 1e3
@@ -2274,10 +2385,22 @@ function registerDiskRoutes(app, pool, store) {
       return c.json({ error: err.message }, 500);
     }
   });
+  app.get("/api/disk/table-history/:table", (c) => {
+    try {
+      const table = c.req.param("table");
+      const range = c.req.query("range") || "24h";
+      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["24h"];
+      const now = Date.now();
+      const data = store.query(`table_size:${table}`, now - rangeMs, now);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
   app.get("/api/disk/history", (c) => {
     try {
       const range = c.req.query("range") || "24h";
-      const rangeMs = RANGE_MAP2[range] || RANGE_MAP2["24h"];
+      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["24h"];
       const now = Date.now();
       const data = store.query("db_size_bytes", now - rangeMs, now);
       return c.json(data);
@@ -2476,7 +2599,7 @@ var QueryStatsStore = class {
 };
 
 // src/server/routes/query-stats.ts
-var RANGE_MAP3 = {
+var RANGE_MAP4 = {
   "1h": 60 * 60 * 1e3,
   "6h": 6 * 60 * 60 * 1e3,
   "24h": 24 * 60 * 60 * 1e3,
@@ -2488,7 +2611,7 @@ function registerQueryStatsRoutes(app, store) {
       const range = c.req.query("range") || "1h";
       const orderBy = c.req.query("orderBy") || "total_time";
       const limit = parseInt(c.req.query("limit") || "20", 10);
-      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["1h"];
+      const rangeMs = RANGE_MAP4[range] || RANGE_MAP4["1h"];
       const now = Date.now();
       const data = store.getTopQueries(now - rangeMs, now, orderBy, limit);
       return c.json(data);
@@ -2500,7 +2623,7 @@ function registerQueryStatsRoutes(app, store) {
     try {
       const queryid = c.req.param("queryid");
       const range = c.req.query("range") || "1h";
-      const rangeMs = RANGE_MAP3[range] || RANGE_MAP3["1h"];
+      const rangeMs = RANGE_MAP4[range] || RANGE_MAP4["1h"];
       const now = Date.now();
       const data = store.getTrend(queryid, now - rangeMs, now);
       return c.json(data);
@@ -2510,6 +2633,74 @@ function registerQueryStatsRoutes(app, store) {
   });
 }
 
+// src/server/routes/export.ts
+init_advisor();
+function registerExportRoutes(app, pool, longQueryThreshold) {
+  app.get("/api/export", async (c) => {
+    const format = c.req.query("format") || "json";
+    try {
+      const [overview, advisor] = await Promise.all([
+        getOverview(pool),
+        getAdvisorReport(pool, longQueryThreshold)
+      ]);
+      if (format === "md") {
+        const lines = [];
+        lines.push(`# pg-dash Health Report`);
+        lines.push(`
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+        lines.push(`## Overview
+`);
+        lines.push(`- **PostgreSQL**: ${overview.version}`);
+        lines.push(`- **Database Size**: ${overview.dbSize}`);
+        lines.push(`- **Connections**: ${overview.connections.active} active / ${overview.connections.idle} idle / ${overview.connections.max} max`);
+        lines.push(`
+## Health Score: ${advisor.score}/100 (Grade: ${advisor.grade})
+`);
+        lines.push(`### Category Breakdown
+`);
+        lines.push(`| Category | Grade | Score | Issues |`);
+        lines.push(`|----------|-------|-------|--------|`);
+        for (const [cat, b] of Object.entries(advisor.breakdown)) {
+          lines.push(`| ${cat} | ${b.grade} | ${b.score}/100 | ${b.count} |`);
+        }
+        if (advisor.issues.length > 0) {
+          lines.push(`
+### Issues (${advisor.issues.length})
+`);
+          for (const issue of advisor.issues) {
+            const icon = issue.severity === "critical" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+            lines.push(`#### ${icon} [${issue.severity}] ${issue.title}
+`);
+            lines.push(`${issue.description}
+`);
+            lines.push(`**Impact**: ${issue.impact}
+`);
+            lines.push(`**Fix**:
+\`\`\`sql
+${issue.fix}
+\`\`\`
+`);
+          }
+        } else {
+          lines.push(`
+\u2705 No issues found!
+`);
+        }
+        const md = lines.join("\n");
+        c.header("Content-Type", "text/markdown; charset=utf-8");
+        c.header("Content-Disposition", `attachment; filename="pg-dash-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.md"`);
+        return c.body(md);
+      }
+      const data = { overview, advisor, exportedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      c.header("Content-Disposition", `attachment; filename="pg-dash-report-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json"`);
+      return c.json(data);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+}
+
 // src/server/index.ts
 import Database3 from "better-sqlite3";
 import { WebSocketServer, WebSocket } from "ws";
@@ -2610,12 +2801,13 @@ async function startServer(opts) {
   registerOverviewRoutes(app, pool);
   registerMetricsRoutes(app, store, collector);
   registerActivityRoutes(app, pool);
-  registerAdvisorRoutes(app, pool, longQueryThreshold);
+  registerAdvisorRoutes(app, pool, longQueryThreshold, store);
   registerSchemaRoutes(app, pool, schemaTracker);
   registerAlertsRoutes(app, alertManager);
   registerExplainRoutes(app, pool);
   registerDiskRoutes(app, pool, store);
   registerQueryStatsRoutes(app, queryStatsStore);
+  registerExportRoutes(app, pool, longQueryThreshold);
   const uiPath = path3.resolve(__dirname, "ui");
   const MIME_TYPES = {
     ".html": "text/html",
@@ -2763,6 +2955,7 @@ async function startServer(opts) {
           try {
             const report = await getAdvisorReport(pool, longQueryThreshold);
             alertMetrics.health_score = report.score;
+            store.insert("health_score", report.score);
           } catch (err) {
             console.error("[alerts] Error checking health score:", err.message);
           }
@@ -2838,8 +3031,8 @@ async function startServer(opts) {
 }
 
 // src/cli.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 process.on("uncaughtException", (err) => {
   console.error("Uncaught exception:", err);
@@ -2873,13 +3066,15 @@ var { values, positionals } = parseArgs({
     help: { type: "boolean", short: "h" },
     version: { type: "boolean", short: "v" },
     threshold: { type: "string" },
-    format: { type: "string", short: "f" }
+    format: { type: "string", short: "f" },
+    ci: { type: "boolean", default: false },
+    diff: { type: "boolean", default: false }
   }
 });
 if (values.version) {
   try {
-    const __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(fs4.readFileSync(path4.resolve(__dirname2, "../package.json"), "utf-8"));
+    const __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+    const pkg = JSON.parse(fs5.readFileSync(path5.resolve(__dirname2, "../package.json"), "utf-8"));
     console.log(`pg-dash v${pkg.version}`);
   } catch {
     console.log("pg-dash v0.1.0");
@@ -2918,7 +3113,9 @@ Options:
   --query-stats-interval <min> Query stats snapshot interval in minutes (default: 5)
   --long-query-threshold <min> Long query threshold in minutes (default: 5)
   --threshold <score>    Health score threshold for check command (default: 70)
-  -f, --format <fmt>     Output format: text|json (default: text)
+  -f, --format <fmt>     Output format: text|json|md (default: text)
+  --ci                   Output GitHub Actions compatible annotations
+  --diff                 Compare with previous run (saves to ~/.pg-dash/last-check.json)
   -v, --version          Show version
   -h, --help             Show this help
 
@@ -2949,18 +3146,120 @@ if (subcommand === "check") {
   const connectionString = resolveConnectionString(1);
   const threshold = parseInt(values.threshold || "70", 10);
   const format = values.format || "text";
+  const ci = values.ci || false;
+  const useDiff = values.diff || false;
   const { Pool: Pool2 } = await import("pg");
   const { getAdvisorReport: getAdvisorReport2 } = await Promise.resolve().then(() => (init_advisor(), advisor_exports));
+  const { saveSnapshot: saveSnapshot2, loadSnapshot: loadSnapshot2, diffSnapshots: diffSnapshots3 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+  const os4 = await import("os");
   const pool = new Pool2({ connectionString });
+  const checkDataDir = values["data-dir"] || path5.join(os4.homedir(), ".pg-dash");
   try {
     const lqt = parseInt(values["long-query-threshold"] || process.env.PG_DASH_LONG_QUERY_THRESHOLD || "5", 10);
     const report = await getAdvisorReport2(pool, lqt);
+    let diff = null;
+    if (useDiff) {
+      const prev = loadSnapshot2(checkDataDir);
+      if (prev) {
+        diff = diffSnapshots3(prev.result, report);
+      }
+      saveSnapshot2(checkDataDir, report);
+    }
     if (format === "json") {
-      console.log(JSON.stringify(report, null, 2));
-    } else {
+      const output = { ...report };
+      if (diff) output.diff = diff;
+      console.log(JSON.stringify(output, null, 2));
+    } else if (format === "md" || ci && format !== "text") {
+      console.log(`## \u{1F3E5} pg-dash Health Report
+`);
+      if (diff) {
+        const sign = diff.scoreDelta >= 0 ? "+" : "";
+        console.log(`**Score: ${diff.previousScore} \u2192 ${report.score} (${sign}${diff.scoreDelta})**
+`);
+      } else {
+        console.log(`**Score: ${report.score}/100 (${report.grade})**
+`);
+      }
+      console.log(`| Category | Score | Grade | Issues |`);
+      console.log(`|----------|-------|-------|--------|`);
+      for (const [cat, b] of Object.entries(report.breakdown)) {
+        console.log(`| ${cat} | ${b.score} | ${b.grade} | ${b.count} |`);
+      }
+      if (diff) {
+        if (diff.resolvedIssues.length > 0) {
+          console.log(`
+### \u2705 Resolved (${diff.resolvedIssues.length})`);
+          for (const i of diff.resolvedIssues) console.log(`- ~~${i.title}~~`);
+        }
+        if (diff.newIssues.length > 0) {
+          console.log(`
+### \u{1F195} New Issues (${diff.newIssues.length})`);
+          for (const i of diff.newIssues) {
+            const icon = i.severity === "critical" ? "\u{1F534}" : i.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+            console.log(`- ${icon} [${i.severity}] ${i.title}`);
+          }
+        }
+      }
+      if (report.issues.length > 0) {
+        console.log(`
+### \u26A0\uFE0F Issues (${report.issues.length})
+`);
+        for (const issue of report.issues) {
+          const sev = issue.severity === "critical" ? "error" : issue.severity === "warning" ? "warning" : "notice";
+          console.log(`- [${sev}] ${issue.title}`);
+        }
+      } else {
+        console.log(`
+\u2705 No issues found!`);
+      }
+      if (report.batchFixes.length > 0) {
+        console.log(`
+### \u{1F527} Batch Fixes
+`);
+        console.log("```sql");
+        for (const fix of report.batchFixes) {
+          console.log(`-- ${fix.title}`);
+          console.log(fix.sql);
+        }
+        console.log("```");
+      }
+    } else if (ci) {
+      for (const issue of report.issues) {
+        const level = issue.severity === "critical" ? "error" : issue.severity === "warning" ? "warning" : "notice";
+        console.log(`::${level}::${issue.title}: ${issue.description}`);
+      }
       console.log(`
+Health Score: ${report.score}/100 (${report.grade})`);
+      for (const [cat, b] of Object.entries(report.breakdown)) {
+        console.log(`  ${cat.padEnd(14)} ${b.grade} (${b.score}/100) \u2014 ${b.count} issue${b.count !== 1 ? "s" : ""}`);
+      }
+      if (diff) {
+        const sign = diff.scoreDelta >= 0 ? "+" : "";
+        console.log(`
+Score: ${diff.previousScore} \u2192 ${report.score} (${sign}${diff.scoreDelta})`);
+        console.log(`Resolved: ${diff.resolvedIssues.length} issues`);
+        console.log(`New: ${diff.newIssues.length} issues`);
+      }
+    } else {
+      if (diff) {
+        const sign = diff.scoreDelta >= 0 ? "+" : "";
+        console.log(`
+  Score: ${diff.previousScore} \u2192 ${report.score} (${sign}${diff.scoreDelta})
+`);
+        if (diff.resolvedIssues.length > 0) {
+          console.log(`  \u2705 Resolved: ${diff.resolvedIssues.length} issues`);
+          for (const i of diff.resolvedIssues) console.log(`     - ${i.title}`);
+        }
+        if (diff.newIssues.length > 0) {
+          console.log(`  \u{1F195} New: ${diff.newIssues.length} issues`);
+          for (const i of diff.newIssues) console.log(`     - ${i.title}`);
+        }
+        console.log();
+      } else {
+        console.log(`
   Health Score: ${report.score}/100 (Grade: ${report.grade})
 `);
+      }
       for (const [cat, b] of Object.entries(report.breakdown)) {
         console.log(`  ${cat.padEnd(14)} ${b.grade} (${b.score}/100) \u2014 ${b.count} issue${b.count !== 1 ? "s" : ""}`);
       }
@@ -2984,9 +3283,9 @@ if (subcommand === "check") {
   }
 } else if (subcommand === "schema-diff") {
   const connectionString = resolveConnectionString(1);
-  const dataDir = values["data-dir"] || path4.join((await import("os")).homedir(), ".pg-dash");
-  const schemaDbPath = path4.join(dataDir, "schema.db");
-  if (!fs4.existsSync(schemaDbPath)) {
+  const dataDir = values["data-dir"] || path5.join((await import("os")).homedir(), ".pg-dash");
+  const schemaDbPath = path5.join(dataDir, "schema.db");
+  if (!fs5.existsSync(schemaDbPath)) {
     console.error("No schema tracking data found. Run pg-dash server first to collect schema snapshots.");
     process.exit(1);
   }