postgresai 0.14.0-dev.44 → 0.14.0-dev.46

package/dist/bin/postgres-ai.js

@@ -13064,7 +13064,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.14.0-dev.44",
+  version: "0.14.0-dev.46",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -15881,7 +15881,7 @@ var Result = import_lib.default.Result;
 var TypeOverrides = import_lib.default.TypeOverrides;
 var defaults = import_lib.default.defaults;
 // package.json
-var version = "0.14.0-dev.44";
+var version = "0.14.0-dev.46";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -26956,7 +26956,7 @@ function parseVersionNum(versionNum) {
 function formatBytes(bytes) {
   if (bytes === 0)
     return "0 B";
-  const units = ["B", "kB", "MB", "GB", "TB", "PB"];
+  const units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
   const i3 = Math.floor(Math.log(bytes) / Math.log(1024));
   return `${(bytes / Math.pow(1024, i3)).toFixed(2)} ${units[i3]}`;
 }
@@ -27375,12 +27375,216 @@ async function generateH004(client, nodeName = "node-01") {
   };
   return report;
 }
+async function generateD004(client, nodeName) {
+  const report = createBaseReport("D004", "pg_stat_statements and pg_stat_kcache settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+  const pgssSettings = {};
+  for (const [name, setting] of Object.entries(allSettings)) {
+    if (name.startsWith("pg_stat_statements") || name.startsWith("pg_stat_kcache")) {
+      pgssSettings[name] = setting;
+    }
+  }
+  let pgssAvailable = false;
+  let pgssMetricsCount = 0;
+  let pgssTotalCalls = 0;
+  const pgssSampleQueries = [];
+  try {
+    const extCheck = await client.query("select 1 from pg_extension where extname = 'pg_stat_statements'");
+    if (extCheck.rows.length > 0) {
+      pgssAvailable = true;
+      const statsResult = await client.query(`
+        select count(*) as cnt, coalesce(sum(calls), 0) as total_calls
+        from pg_stat_statements
+      `);
+      pgssMetricsCount = parseInt(statsResult.rows[0]?.cnt || "0", 10);
+      pgssTotalCalls = parseInt(statsResult.rows[0]?.total_calls || "0", 10);
+      const sampleResult = await client.query(`
+        select
+          queryid::text as queryid,
+          coalesce(usename, 'unknown') as "user",
+          coalesce(datname, 'unknown') as database,
+          calls
+        from pg_stat_statements s
+        left join pg_database d on s.dbid = d.oid
+        left join pg_user u on s.userid = u.usesysid
+        order by calls desc
+        limit 5
+      `);
+      for (const row of sampleResult.rows) {
+        pgssSampleQueries.push({
+          queryid: row.queryid,
+          user: row.user,
+          database: row.database,
+          calls: parseInt(row.calls, 10)
+        });
+      }
+    }
+  } catch {}
+  let kcacheAvailable = false;
+  let kcacheMetricsCount = 0;
+  let kcacheTotalExecTime = 0;
+  let kcacheTotalUserTime = 0;
+  let kcacheTotalSystemTime = 0;
+  const kcacheSampleQueries = [];
+  try {
+    const extCheck = await client.query("select 1 from pg_extension where extname = 'pg_stat_kcache'");
+    if (extCheck.rows.length > 0) {
+      kcacheAvailable = true;
+      const statsResult = await client.query(`
+        select
+          count(*) as cnt,
+          coalesce(sum(exec_user_time + exec_system_time), 0) as total_exec_time,
+          coalesce(sum(exec_user_time), 0) as total_user_time,
+          coalesce(sum(exec_system_time), 0) as total_system_time
+        from pg_stat_kcache
+      `);
+      kcacheMetricsCount = parseInt(statsResult.rows[0]?.cnt || "0", 10);
+      kcacheTotalExecTime = parseFloat(statsResult.rows[0]?.total_exec_time || "0");
+      kcacheTotalUserTime = parseFloat(statsResult.rows[0]?.total_user_time || "0");
+      kcacheTotalSystemTime = parseFloat(statsResult.rows[0]?.total_system_time || "0");
+      const sampleResult = await client.query(`
+        select
+          queryid::text as queryid,
+          coalesce(usename, 'unknown') as "user",
+          (exec_user_time + exec_system_time) as exec_total_time
+        from pg_stat_kcache k
+        left join pg_user u on k.userid = u.usesysid
+        order by (exec_user_time + exec_system_time) desc
+        limit 5
+      `);
+      for (const row of sampleResult.rows) {
+        kcacheSampleQueries.push({
+          queryid: row.queryid,
+          user: row.user,
+          exec_total_time: parseFloat(row.exec_total_time)
+        });
+      }
+    }
+  } catch {}
+  report.results[nodeName] = {
+    data: {
+      settings: pgssSettings,
+      pg_stat_statements_status: {
+        extension_available: pgssAvailable,
+        metrics_count: pgssMetricsCount,
+        total_calls: pgssTotalCalls,
+        sample_queries: pgssSampleQueries
+      },
+      pg_stat_kcache_status: {
+        extension_available: kcacheAvailable,
+        metrics_count: kcacheMetricsCount,
+        total_exec_time: kcacheTotalExecTime,
+        total_user_time: kcacheTotalUserTime,
+        total_system_time: kcacheTotalSystemTime,
+        sample_queries: kcacheSampleQueries
+      }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
+async function generateF001(client, nodeName) {
+  const report = createBaseReport("F001", "Autovacuum: current settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+  const autovacuumSettings = {};
+  for (const [name, setting] of Object.entries(allSettings)) {
+    if (name.includes("autovacuum") || name.includes("vacuum")) {
+      autovacuumSettings[name] = setting;
+    }
+  }
+  report.results[nodeName] = {
+    data: autovacuumSettings,
+    postgres_version: postgresVersion
+  };
+  return report;
+}
+async function generateG001(client, nodeName) {
+  const report = createBaseReport("G001", "Memory-related settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+  const memorySettingNames = [
+    "shared_buffers",
+    "work_mem",
+    "maintenance_work_mem",
+    "effective_cache_size",
+    "wal_buffers",
+    "temp_buffers",
+    "max_connections",
+    "autovacuum_work_mem",
+    "hash_mem_multiplier",
+    "logical_decoding_work_mem",
+    "max_stack_depth",
+    "max_prepared_transactions",
+    "max_locks_per_transaction",
+    "max_pred_locks_per_transaction"
+  ];
+  const memorySettings = {};
+  for (const name of memorySettingNames) {
+    if (allSettings[name]) {
+      memorySettings[name] = allSettings[name];
+    }
+  }
+  let memoryUsage = {};
+  try {
+    const memQuery = await client.query(`
+      select
+        pg_size_bytes(current_setting('shared_buffers')) as shared_buffers_bytes,
+        pg_size_bytes(current_setting('wal_buffers')) as wal_buffers_bytes,
+        pg_size_bytes(current_setting('work_mem')) as work_mem_bytes,
+        pg_size_bytes(current_setting('maintenance_work_mem')) as maintenance_work_mem_bytes,
+        pg_size_bytes(current_setting('effective_cache_size')) as effective_cache_size_bytes,
+        current_setting('max_connections')::int as max_connections
+    `);
+    if (memQuery.rows.length > 0) {
+      const row = memQuery.rows[0];
+      const sharedBuffersBytes = parseInt(row.shared_buffers_bytes, 10);
+      const walBuffersBytes = parseInt(row.wal_buffers_bytes, 10);
+      const workMemBytes = parseInt(row.work_mem_bytes, 10);
+      const maintenanceWorkMemBytes = parseInt(row.maintenance_work_mem_bytes, 10);
+      const effectiveCacheSizeBytes = parseInt(row.effective_cache_size_bytes, 10);
+      const maxConnections = row.max_connections;
+      const sharedMemoryTotal = sharedBuffersBytes + walBuffersBytes;
+      const maxWorkMemUsage = workMemBytes * maxConnections;
+      memoryUsage = {
+        shared_buffers_bytes: sharedBuffersBytes,
+        shared_buffers_pretty: formatBytes(sharedBuffersBytes),
+        wal_buffers_bytes: walBuffersBytes,
+        wal_buffers_pretty: formatBytes(walBuffersBytes),
+        shared_memory_total_bytes: sharedMemoryTotal,
+        shared_memory_total_pretty: formatBytes(sharedMemoryTotal),
+        work_mem_per_connection_bytes: workMemBytes,
+        work_mem_per_connection_pretty: formatBytes(workMemBytes),
+        max_work_mem_usage_bytes: maxWorkMemUsage,
+        max_work_mem_usage_pretty: formatBytes(maxWorkMemUsage),
+        maintenance_work_mem_bytes: maintenanceWorkMemBytes,
+        maintenance_work_mem_pretty: formatBytes(maintenanceWorkMemBytes),
+        effective_cache_size_bytes: effectiveCacheSizeBytes,
+        effective_cache_size_pretty: formatBytes(effectiveCacheSizeBytes)
+      };
+    }
+  } catch {}
+  report.results[nodeName] = {
+    data: {
+      settings: memorySettings,
+      analysis: {
+        estimated_total_memory_usage: memoryUsage
+      }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 var REPORT_GENERATORS = {
   A002: generateA002,
   A003: generateA003,
   A004: generateA004,
   A007: generateA007,
   A013: generateA013,
+  D004: generateD004,
+  F001: generateF001,
+  G001: generateG001,
   H001: generateH001,
   H002: generateH002,
   H004: generateH004
@@ -27391,6 +27595,9 @@ var CHECK_INFO = {
   A004: "Cluster information",
   A007: "Altered settings",
   A013: "Postgres minor version",
+  D004: "pg_stat_statements and pg_stat_kcache settings",
+  F001: "Autovacuum: current settings",
+  G001: "Memory-related settings",
   H001: "Invalid indexes",
   H002: "Unused indexes",
   H004: "Redundant indexes"

package/lib/checkup.ts

@@ -186,11 +186,15 @@ export function parseVersionNum(versionNum: string): { major: string; minor: str
 }
 
 /**
- * Format bytes to human readable string
+ * Format bytes to human readable string using binary units (1024-based).
+ * Uses IEC standard: KiB, MiB, GiB, etc.
+ * 
+ * Note: PostgreSQL's pg_size_pretty() uses kB/MB/GB with 1024 base (technically
+ * incorrect SI usage), but we follow IEC binary units per project style guide.
  */
 export function formatBytes(bytes: number): string {
   if (bytes === 0) return "0 B";
-  const units = ["B", "kB", "MB", "GB", "TB", "PB"];
+  const units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
   return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
 }
@@ -776,6 +780,276 @@ export async function generateH004(client: Client, nodeName: string = "node-01")
   return report;
 }
 
+/**
+ * Generate D004 report - pg_stat_statements and pg_stat_kcache settings
+ */
+async function generateD004(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("D004", "pg_stat_statements and pg_stat_kcache settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+
+  // Filter settings related to pg_stat_statements and pg_stat_kcache
+  const pgssSettings: Record<string, SettingInfo> = {};
+  for (const [name, setting] of Object.entries(allSettings)) {
+    if (name.startsWith("pg_stat_statements") || name.startsWith("pg_stat_kcache")) {
+      pgssSettings[name] = setting;
+    }
+  }
+
+  // Check pg_stat_statements extension
+  let pgssAvailable = false;
+  let pgssMetricsCount = 0;
+  let pgssTotalCalls = 0;
+  const pgssSampleQueries: Array<{ queryid: string; user: string; database: string; calls: number }> = [];
+
+  try {
+    const extCheck = await client.query(
+      "select 1 from pg_extension where extname = 'pg_stat_statements'"
+    );
+    if (extCheck.rows.length > 0) {
+      pgssAvailable = true;
+      const statsResult = await client.query(`
+        select count(*) as cnt, coalesce(sum(calls), 0) as total_calls
+        from pg_stat_statements
+      `);
+      pgssMetricsCount = parseInt(statsResult.rows[0]?.cnt || "0", 10);
+      pgssTotalCalls = parseInt(statsResult.rows[0]?.total_calls || "0", 10);
+
+      // Get sample queries (top 5 by calls)
+      const sampleResult = await client.query(`
+        select
+          queryid::text as queryid,
+          coalesce(usename, 'unknown') as "user",
+          coalesce(datname, 'unknown') as database,
+          calls
+        from pg_stat_statements s
+        left join pg_database d on s.dbid = d.oid
+        left join pg_user u on s.userid = u.usesysid
+        order by calls desc
+        limit 5
+      `);
+      for (const row of sampleResult.rows) {
+        pgssSampleQueries.push({
+          queryid: row.queryid,
+          user: row.user,
+          database: row.database,
+          calls: parseInt(row.calls, 10),
+        });
+      }
+    }
+  } catch {
+    // Extension not available or accessible
+  }
+
+  // Check pg_stat_kcache extension
+  let kcacheAvailable = false;
+  let kcacheMetricsCount = 0;
+  let kcacheTotalExecTime = 0;
+  let kcacheTotalUserTime = 0;
+  let kcacheTotalSystemTime = 0;
+  const kcacheSampleQueries: Array<{ queryid: string; user: string; exec_total_time: number }> = [];
+
+  try {
+    const extCheck = await client.query(
+      "select 1 from pg_extension where extname = 'pg_stat_kcache'"
+    );
+    if (extCheck.rows.length > 0) {
+      kcacheAvailable = true;
+      const statsResult = await client.query(`
+        select
+          count(*) as cnt,
+          coalesce(sum(exec_user_time + exec_system_time), 0) as total_exec_time,
+          coalesce(sum(exec_user_time), 0) as total_user_time,
+          coalesce(sum(exec_system_time), 0) as total_system_time
+        from pg_stat_kcache
+      `);
+      kcacheMetricsCount = parseInt(statsResult.rows[0]?.cnt || "0", 10);
+      kcacheTotalExecTime = parseFloat(statsResult.rows[0]?.total_exec_time || "0");
+      kcacheTotalUserTime = parseFloat(statsResult.rows[0]?.total_user_time || "0");
+      kcacheTotalSystemTime = parseFloat(statsResult.rows[0]?.total_system_time || "0");
+
+      // Get sample queries (top 5 by exec time)
+      const sampleResult = await client.query(`
+        select
+          queryid::text as queryid,
+          coalesce(usename, 'unknown') as "user",
+          (exec_user_time + exec_system_time) as exec_total_time
+        from pg_stat_kcache k
+        left join pg_user u on k.userid = u.usesysid
+        order by (exec_user_time + exec_system_time) desc
+        limit 5
+      `);
+      for (const row of sampleResult.rows) {
+        kcacheSampleQueries.push({
+          queryid: row.queryid,
+          user: row.user,
+          exec_total_time: parseFloat(row.exec_total_time),
+        });
+      }
+    }
+  } catch {
+    // Extension not available or accessible
+  }
+
+  report.results[nodeName] = {
+    data: {
+      settings: pgssSettings,
+      pg_stat_statements_status: {
+        extension_available: pgssAvailable,
+        metrics_count: pgssMetricsCount,
+        total_calls: pgssTotalCalls,
+        sample_queries: pgssSampleQueries,
+      },
+      pg_stat_kcache_status: {
+        extension_available: kcacheAvailable,
+        metrics_count: kcacheMetricsCount,
+        total_exec_time: kcacheTotalExecTime,
+        total_user_time: kcacheTotalUserTime,
+        total_system_time: kcacheTotalSystemTime,
+        sample_queries: kcacheSampleQueries,
+      },
+    },
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
+/**
+ * Generate F001 report - Autovacuum: current settings
+ */
+async function generateF001(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("F001", "Autovacuum: current settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+
+  // Filter autovacuum-related settings
+  const autovacuumSettings: Record<string, SettingInfo> = {};
+  for (const [name, setting] of Object.entries(allSettings)) {
+    if (name.includes("autovacuum") || name.includes("vacuum")) {
+      autovacuumSettings[name] = setting;
+    }
+  }
+
+  report.results[nodeName] = {
+    data: autovacuumSettings,
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
+/**
+ * Generate G001 report - Memory-related settings
+ */
+async function generateG001(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("G001", "Memory-related settings", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const allSettings = await getSettings(client);
+
+  // Memory-related setting names
+  const memorySettingNames = [
+    "shared_buffers",
+    "work_mem",
+    "maintenance_work_mem",
+    "effective_cache_size",
+    "wal_buffers",
+    "temp_buffers",
+    "max_connections",
+    "autovacuum_work_mem",
+    "hash_mem_multiplier",
+    "logical_decoding_work_mem",
+    "max_stack_depth",
+    "max_prepared_transactions",
+    "max_locks_per_transaction",
+    "max_pred_locks_per_transaction",
+  ];
+
+  const memorySettings: Record<string, SettingInfo> = {};
+  for (const name of memorySettingNames) {
+    if (allSettings[name]) {
+      memorySettings[name] = allSettings[name];
+    }
+  }
+
+  // Calculate memory usage estimates
+  interface MemoryUsage {
+    shared_buffers_bytes: number;
+    shared_buffers_pretty: string;
+    wal_buffers_bytes: number;
+    wal_buffers_pretty: string;
+    shared_memory_total_bytes: number;
+    shared_memory_total_pretty: string;
+    work_mem_per_connection_bytes: number;
+    work_mem_per_connection_pretty: string;
+    max_work_mem_usage_bytes: number;
+    max_work_mem_usage_pretty: string;
+    maintenance_work_mem_bytes: number;
+    maintenance_work_mem_pretty: string;
+    effective_cache_size_bytes: number;
+    effective_cache_size_pretty: string;
+  }
+
+  let memoryUsage: MemoryUsage | Record<string, never> = {};
+
+  try {
+    // Get actual byte values from PostgreSQL
+    const memQuery = await client.query(`
+      select
+        pg_size_bytes(current_setting('shared_buffers')) as shared_buffers_bytes,
+        pg_size_bytes(current_setting('wal_buffers')) as wal_buffers_bytes,
+        pg_size_bytes(current_setting('work_mem')) as work_mem_bytes,
+        pg_size_bytes(current_setting('maintenance_work_mem')) as maintenance_work_mem_bytes,
+        pg_size_bytes(current_setting('effective_cache_size')) as effective_cache_size_bytes,
+        current_setting('max_connections')::int as max_connections
+    `);
+
+    if (memQuery.rows.length > 0) {
+      const row = memQuery.rows[0];
+      const sharedBuffersBytes = parseInt(row.shared_buffers_bytes, 10);
+      const walBuffersBytes = parseInt(row.wal_buffers_bytes, 10);
+      const workMemBytes = parseInt(row.work_mem_bytes, 10);
+      const maintenanceWorkMemBytes = parseInt(row.maintenance_work_mem_bytes, 10);
+      const effectiveCacheSizeBytes = parseInt(row.effective_cache_size_bytes, 10);
+      const maxConnections = row.max_connections;
+
+      const sharedMemoryTotal = sharedBuffersBytes + walBuffersBytes;
+      const maxWorkMemUsage = workMemBytes * maxConnections;
+
+      memoryUsage = {
+        shared_buffers_bytes: sharedBuffersBytes,
+        shared_buffers_pretty: formatBytes(sharedBuffersBytes),
+        wal_buffers_bytes: walBuffersBytes,
+        wal_buffers_pretty: formatBytes(walBuffersBytes),
+        shared_memory_total_bytes: sharedMemoryTotal,
+        shared_memory_total_pretty: formatBytes(sharedMemoryTotal),
+        work_mem_per_connection_bytes: workMemBytes,
+        work_mem_per_connection_pretty: formatBytes(workMemBytes),
+        max_work_mem_usage_bytes: maxWorkMemUsage,
+        max_work_mem_usage_pretty: formatBytes(maxWorkMemUsage),
+        maintenance_work_mem_bytes: maintenanceWorkMemBytes,
+        maintenance_work_mem_pretty: formatBytes(maintenanceWorkMemBytes),
+        effective_cache_size_bytes: effectiveCacheSizeBytes,
+        effective_cache_size_pretty: formatBytes(effectiveCacheSizeBytes),
+      };
+    }
+  } catch {
+    // If we can't calculate, leave empty object (schema allows this)
+  }
+
+  report.results[nodeName] = {
+    data: {
+      settings: memorySettings,
+      analysis: {
+        estimated_total_memory_usage: memoryUsage,
+      },
+    },
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
 /**
  * Available report generators
  */
@@ -785,6 +1059,9 @@ export const REPORT_GENERATORS: Record<string, (client: Client, nodeName: string
   A004: generateA004,
   A007: generateA007,
   A013: generateA013,
+  D004: generateD004,
+  F001: generateF001,
+  G001: generateG001,
   H001: generateH001,
   H002: generateH002,
   H004: generateH004,
@@ -799,6 +1076,9 @@ export const CHECK_INFO: Record<string, string> = {
   A004: "Cluster information",
   A007: "Altered settings",
   A013: "Postgres minor version",
+  D004: "pg_stat_statements and pg_stat_kcache settings",
+  F001: "Autovacuum: current settings",
+  G001: "Memory-related settings",
   H001: "Invalid indexes",
   H002: "Unused indexes",
   H004: "Redundant indexes",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresai",
-  "version": "0.14.0-dev.44",
+  "version": "0.14.0-dev.46",
   "description": "postgres_ai CLI",
   "license": "Apache-2.0",
   "private": false,

package/test/checkup.test.ts

@@ -99,6 +99,25 @@ function createMockClient(versionRows: any[], settingsRows: any[], options: Mock
       if (sql.includes("redundant_indexes") && sql.includes("columns like")) {
         return { rows: redundantIndexesRows };
       }
+      // D004: pg_stat_statements extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_statements")) {
+        return { rows: [] }; // Extension not installed by default
+      }
+      // D004: pg_stat_kcache extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_kcache")) {
+        return { rows: [] }; // Extension not installed by default
+      }
+      // G001: Memory settings query
+      if (sql.includes("pg_size_bytes") && sql.includes("shared_buffers") && sql.includes("work_mem")) {
+        return { rows: [{
+          shared_buffers_bytes: "134217728",
+          wal_buffers_bytes: "4194304",
+          work_mem_bytes: "4194304",
+          maintenance_work_mem_bytes: "67108864",
+          effective_cache_size_bytes: "4294967296",
+          max_connections: 100,
+        }] };
+      }
       throw new Error(`Unexpected query: ${sql}`);
     },
   };
@@ -208,6 +227,21 @@ describe("CHECK_INFO", () => {
     expect("H004" in checkup.CHECK_INFO).toBe(true);
     expect(checkup.CHECK_INFO.H004).toBe("Redundant indexes");
   });
+
+  test("contains D004", () => {
+    expect("D004" in checkup.CHECK_INFO).toBe(true);
+    expect(checkup.CHECK_INFO.D004).toBe("pg_stat_statements and pg_stat_kcache settings");
+  });
+
+  test("contains F001", () => {
+    expect("F001" in checkup.CHECK_INFO).toBe(true);
+    expect(checkup.CHECK_INFO.F001).toBe("Autovacuum: current settings");
+  });
+
+  test("contains G001", () => {
+    expect("G001" in checkup.CHECK_INFO).toBe(true);
+    expect(checkup.CHECK_INFO.G001).toBe("Memory-related settings");
+  });
 });
 
 // Tests for REPORT_GENERATORS
@@ -252,6 +286,21 @@ describe("REPORT_GENERATORS", () => {
     expect(typeof checkup.REPORT_GENERATORS.H004).toBe("function");
   });
 
+  test("has generator for D004", () => {
+    expect("D004" in checkup.REPORT_GENERATORS).toBe(true);
+    expect(typeof checkup.REPORT_GENERATORS.D004).toBe("function");
+  });
+
+  test("has generator for F001", () => {
+    expect("F001" in checkup.REPORT_GENERATORS).toBe(true);
+    expect(typeof checkup.REPORT_GENERATORS.F001).toBe("function");
+  });
+
+  test("has generator for G001", () => {
+    expect("G001" in checkup.REPORT_GENERATORS).toBe(true);
+    expect(typeof checkup.REPORT_GENERATORS.G001).toBe("function");
+  });
+
   test("REPORT_GENERATORS and CHECK_INFO have same keys", () => {
     const generatorKeys = Object.keys(checkup.REPORT_GENERATORS).sort();
     const infoKeys = Object.keys(checkup.CHECK_INFO).sort();
@@ -269,17 +318,17 @@ describe("formatBytes", () => {
     expect(checkup.formatBytes(500)).toBe("500.00 B");
   });
 
-  test("formats kilobytes", () => {
-    expect(checkup.formatBytes(1024)).toBe("1.00 kB");
-    expect(checkup.formatBytes(1536)).toBe("1.50 kB");
+  test("formats kibibytes", () => {
+    expect(checkup.formatBytes(1024)).toBe("1.00 KiB");
+    expect(checkup.formatBytes(1536)).toBe("1.50 KiB");
   });
 
-  test("formats megabytes", () => {
-    expect(checkup.formatBytes(1048576)).toBe("1.00 MB");
+  test("formats mebibytes", () => {
+    expect(checkup.formatBytes(1048576)).toBe("1.00 MiB");
   });
 
-  test("formats gigabytes", () => {
-    expect(checkup.formatBytes(1073741824)).toBe("1.00 GB");
+  test("formats gibibytes", () => {
+    expect(checkup.formatBytes(1073741824)).toBe("1.00 GiB");
   });
 });
 

package/test/init.integration.test.ts

@@ -213,7 +213,7 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 
   test("requires explicit monitoring password in non-interactive mode", async () => {
     pg = await createTempPostgres();
@@ -237,7 +237,7 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 
   test("fixes slightly-off permissions idempotently", async () => {
     pg = await createTempPostgres();
@@ -291,7 +291,7 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 
   test("reports nicely when lacking permissions", async () => {
     pg = await createTempPostgres();
@@ -324,7 +324,7 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 
   test("--verify returns 0 when ok and non-zero when missing", async () => {
     pg = await createTempPostgres();
@@ -360,7 +360,7 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 
   test("--reset-password updates the monitoring role login password", async () => {
     pg = await createTempPostgres();
@@ -392,5 +392,5 @@ describe.skipIf(skipTests)("integration: prepare-db", () => {
     } finally {
       await pg.cleanup();
     }
-  });
+  }, { timeout: 30000 });
 });

package/test/schema-validation.test.ts

@@ -28,6 +28,7 @@ function validateReport(report: any, checkId: string): { valid: boolean; errors:
 // Mock client for testing
 function createMockClient(options: {
   versionRows?: any[];
+  settingsRows?: any[];
   invalidIndexesRows?: any[];
   unusedIndexesRows?: any[];
   redundantIndexesRows?: any[];
@@ -37,6 +38,12 @@ function createMockClient(options: {
       { name: "server_version", setting: "16.3" },
       { name: "server_version_num", setting: "160003" },
     ],
+    settingsRows = [
+      { name: "shared_buffers", setting: "128MB", unit: "", category: "Resource Usage / Memory", context: "postmaster", vartype: "string", pretty_value: "128 MB" },
+      { name: "work_mem", setting: "4MB", unit: "", category: "Resource Usage / Memory", context: "user", vartype: "string", pretty_value: "4 MB" },
+      { name: "autovacuum", setting: "on", unit: "", category: "Autovacuum", context: "sighup", vartype: "bool", pretty_value: "on" },
+      { name: "pg_stat_statements.max", setting: "5000", unit: "", category: "Custom", context: "superuser", vartype: "integer", pretty_value: "5000" },
+    ],
     invalidIndexesRows = [],
     unusedIndexesRows = [],
     redundantIndexesRows = [],
@@ -47,6 +54,10 @@ function createMockClient(options: {
       if (sql.includes("server_version") && sql.includes("server_version_num") && !sql.includes("order by")) {
         return { rows: versionRows };
       }
+      // Full settings query
+      if (sql.includes("pg_settings") && sql.includes("order by") && sql.includes("is_default")) {
+        return { rows: settingsRows };
+      }
       if (sql.includes("current_database()") && sql.includes("pg_database_size")) {
         return { rows: [{ datname: "testdb", size_bytes: "1073741824" }] };
       }
@@ -68,6 +79,25 @@ function createMockClient(options: {
       if (sql.includes("redundant_indexes") && sql.includes("columns like")) {
         return { rows: redundantIndexesRows };
       }
+      // D004: pg_stat_statements extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_statements")) {
+        return { rows: [] }; // Extension not installed
+      }
+      // D004: pg_stat_kcache extension check
+      if (sql.includes("pg_extension") && sql.includes("pg_stat_kcache")) {
+        return { rows: [] }; // Extension not installed
+      }
+      // G001: Memory settings query
+      if (sql.includes("pg_size_bytes") && sql.includes("shared_buffers") && sql.includes("work_mem")) {
+        return { rows: [{
+          shared_buffers_bytes: "134217728",
+          wal_buffers_bytes: "4194304",
+          work_mem_bytes: "4194304",
+          maintenance_work_mem_bytes: "67108864",
+          effective_cache_size_bytes: "4294967296",
+          max_connections: 100,
+        }] };
+      }
       throw new Error(`Unexpected query: ${sql}`);
     },
   };
@@ -186,3 +216,42 @@ describe("H004 schema validation", () => {
   });
 });
 
+describe("D004 schema validation", () => {
+  test("D004 report validates against schema (extensions not installed)", async () => {
+    const mockClient = createMockClient();
+    const report = await checkup.REPORT_GENERATORS.D004(mockClient as any, "node-01");
+    
+    const result = validateReport(report, "D004");
+    if (!result.valid) {
+      console.error("D004 validation errors:", result.errors);
+    }
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe("F001 schema validation", () => {
+  test("F001 report validates against schema", async () => {
+    const mockClient = createMockClient();
+    const report = await checkup.REPORT_GENERATORS.F001(mockClient as any, "node-01");
+    
+    const result = validateReport(report, "F001");
+    if (!result.valid) {
+      console.error("F001 validation errors:", result.errors);
+    }
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe("G001 schema validation", () => {
+  test("G001 report validates against schema", async () => {
+    const mockClient = createMockClient();
+    const report = await checkup.REPORT_GENERATORS.G001(mockClient as any, "node-01");
+    
+    const result = validateReport(report, "G001");
+    if (!result.valid) {
+      console.error("G001 validation errors:", result.errors);
+    }
+    expect(result.valid).toBe(true);
+  });
+});
+