postgresai 0.14.0-dev.80 → 0.14.0-dev.82

package/dist/bin/postgres-ai.js

@@ -13064,7 +13064,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.14.0-dev.80",
+  version: "0.14.0-dev.82",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -13098,7 +13098,7 @@ var package_default = {
     "start:node": "node ./dist/bin/postgres-ai.js --help",
     dev: "bun run embed-all && bun --watch ./bin/postgres-ai.ts",
     test: "bun run embed-all && bun test",
-    "test:fast": "bun run embed-all && bun test",
+    "test:fast": "bun run embed-all && bun test --coverage=false",
     "test:coverage": "bun run embed-all && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
     typecheck: "bun run embed-all && bunx tsc --noEmit"
   },
@@ -15889,7 +15889,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.80";
+var version = "0.14.0-dev.82";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -15926,7 +15926,7 @@ var package_default2 = {
     "start:node": "node ./dist/bin/postgres-ai.js --help",
     dev: "bun run embed-all && bun --watch ./bin/postgres-ai.ts",
     test: "bun run embed-all && bun test",
-    "test:fast": "bun run embed-all && bun test",
+    "test:fast": "bun run embed-all && bun test --coverage=false",
     "test:coverage": "bun run embed-all && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
     typecheck: "bun run embed-all && bunx tsc --noEmit"
   },
@@ -27103,7 +27103,7 @@ var CHECKUP_DICTIONARY_DATA = [
 ];
 
 // lib/checkup-dictionary.ts
-var dictionaryByCode = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code, entry]));
+var dictionaryByCode = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code.toUpperCase(), entry]));
 function buildCheckInfoMap() {
   const result = {};
   for (const entry of CHECKUP_DICTIONARY_DATA) {
@@ -27789,6 +27789,218 @@ async function generateF001(client, nodeName) {
   };
   return report;
 }
+async function generateF004(client, nodeName) {
+  const report = createBaseReport("F004", "Autovacuum: heap bloat estimate", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  let bloatData = [];
+  let bloatError = null;
+  try {
+    const result = await client.query(`
+      select
+        schemaname,
+        tblname,
+        (bs * tblpages)::bigint as real_size_bytes,
+        pg_size_pretty((bs * tblpages)::bigint) as real_size_pretty,
+        ((tblpages - est_tblpages) * bs)::bigint as extra_size_bytes,
+        pg_size_pretty(((tblpages - est_tblpages) * bs)::bigint) as extra_size_pretty,
+        case when tblpages > 0 and tblpages - est_tblpages > 0
+          then round(100.0 * (tblpages - est_tblpages) / tblpages, 2)
+          else 0
+        end as extra_pct,
+        fillfactor,
+        case when tblpages - est_tblpages_ff > 0
+          then ((tblpages - est_tblpages_ff) * bs)::bigint
+          else 0
+        end as bloat_size_bytes,
+        pg_size_pretty(case when tblpages - est_tblpages_ff > 0
+          then ((tblpages - est_tblpages_ff) * bs)::bigint
+          else 0
+        end) as bloat_size_pretty,
+        case when tblpages > 0 and tblpages - est_tblpages_ff > 0
+          then round(100.0 * (tblpages - est_tblpages_ff) / tblpages, 2)
+          else 0
+        end as bloat_pct,
+        is_na::text
+      from (
+        select
+          ceil(reltuples / ((bs - page_hdr) / tpl_size)) + ceil(toasttuples / 4) as est_tblpages,
+          ceil(reltuples / ((bs - page_hdr) * fillfactor / (tpl_size * 100))) + ceil(toasttuples / 4) as est_tblpages_ff,
+          tblpages, fillfactor, bs, schemaname, tblname, is_na
+        from (
+          select
+            (4 + tpl_hdr_size + tpl_data_size + (2 * ma)
+              - case when tpl_hdr_size % ma = 0 then ma else tpl_hdr_size % ma end
+              - case when ceil(tpl_data_size)::int % ma = 0 then ma else ceil(tpl_data_size)::int % ma end
+            ) as tpl_size,
+            (heappages + toastpages) as tblpages,
+            reltuples, toasttuples, bs, page_hdr, schemaname, tblname, fillfactor, is_na
+          from (
+            select
+              ns.nspname as schemaname,
+              tbl.relname as tblname,
+              tbl.reltuples,
+              tbl.relpages as heappages,
+              coalesce(toast.relpages, 0) as toastpages,
+              coalesce(toast.reltuples, 0) as toasttuples,
+              coalesce(substring(array_to_string(tbl.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 100) as fillfactor,
+              current_setting('block_size')::numeric as bs,
+              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as ma,
+              24 as page_hdr,
+              23 + case when max(coalesce(s.null_frac, 0)) > 0 then (7 + count(s.attname)) / 8 else 0::int end
+                + case when bool_or(att.attname = 'oid' and att.attnum < 0) then 4 else 0 end as tpl_hdr_size,
+              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 0)) as tpl_data_size,
+              (bool_or(att.atttypid = 'pg_catalog.name'::regtype)
+                or sum(case when att.attnum > 0 then 1 else 0 end) <> count(s.attname))::int as is_na
+            from pg_attribute as att
+              join pg_class as tbl on att.attrelid = tbl.oid
+              join pg_namespace as ns on ns.oid = tbl.relnamespace
+              left join pg_stats as s on s.schemaname = ns.nspname
+                and s.tablename = tbl.relname and s.attname = att.attname
+              left join pg_class as toast on tbl.reltoastrelid = toast.oid
+            where not att.attisdropped
+              and tbl.relkind in ('r', 'm')
+              and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
+            group by ns.nspname, tbl.relname, tbl.reltuples, tbl.relpages, toast.relpages, toast.reltuples, tbl.reloptions
+          ) as s
+        ) as s2
+      ) as s3
+      where tblpages > 0 and (bs * tblpages) >= 1024 * 1024  -- exclude tables < 1 MiB
+      order by bloat_size_bytes desc
+      limit 100
+    `);
+    bloatData = result.rows;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F004] Error estimating table bloat: ${errorMsg}`);
+    bloatError = errorMsg;
+  }
+  report.results[nodeName] = {
+    data: {
+      tables: bloatData,
+      ...bloatError && { error: bloatError }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
+async function generateF005(client, nodeName) {
+  const report = createBaseReport("F005", "Autovacuum: index bloat estimate", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  let bloatData = [];
+  let bloatError = null;
+  try {
+    const result = await client.query(`
+      select
+        nspname as schemaname,
+        tblname,
+        idxname,
+        (bs * relpages)::bigint as real_size_bytes,
+        pg_size_pretty((bs * relpages)::bigint) as real_size_pretty,
+        pg_relation_size(tbloid)::bigint as table_size_bytes,
+        pg_size_pretty(pg_relation_size(tbloid)) as table_size_pretty,
+        ((relpages - est_pages) * bs)::bigint as extra_size_bytes,
+        pg_size_pretty(((relpages - est_pages) * bs)::bigint) as extra_size_pretty,
+        round(100.0 * (relpages - est_pages) / relpages, 2) as extra_pct,
+        fillfactor,
+        case when relpages > est_pages_ff
+          then ((relpages - est_pages_ff) * bs)::bigint
+          else 0
+        end as bloat_size_bytes,
+        pg_size_pretty(case when relpages > est_pages_ff
+          then ((relpages - est_pages_ff) * bs)::bigint
+          else 0
+        end) as bloat_size_pretty,
+        case when relpages > est_pages_ff
+          then round(100.0 * (relpages - est_pages_ff) / relpages, 2)
+          else 0
+        end as bloat_pct,
+        is_na::text
+      from (
+        select
+          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) / (4 + nulldatahdrwidth)::float)), 0) as est_pages,
+          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) * fillfactor / (100 * (4 + nulldatahdrwidth)::float))), 0) as est_pages_ff,
+          bs, nspname, tblname, idxname, relpages, fillfactor, is_na, tbloid
+        from (
+          select
+            maxalign, bs, nspname, tblname, idxname, reltuples, relpages, idxoid, fillfactor, tbloid,
+            (index_tuple_hdr_bm + maxalign
+              - case when index_tuple_hdr_bm % maxalign = 0 then maxalign else index_tuple_hdr_bm % maxalign end
+              + nulldatawidth + maxalign
+              - case when nulldatawidth = 0 then 0
+                     when nulldatawidth::integer % maxalign = 0 then maxalign
+                     else nulldatawidth::integer % maxalign end
+            )::numeric as nulldatahdrwidth,
+            pagehdr, pageopqdata, is_na
+          from (
+            select
+              n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor,
+              current_setting('block_size')::numeric as bs,
+              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as maxalign,
+              24 as pagehdr,
+              16 as pageopqdata,
+              case when max(coalesce(s.null_frac, 0)) = 0
+                then 8
+                else 8 + ((32 + 8 - 1) / 8)
+              end as index_tuple_hdr_bm,
+              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 1024)) as nulldatawidth,
+              (max(case when i.atttypid = 'pg_catalog.name'::regtype then 1 else 0 end) > 0)::int as is_na
+            from (
+              select
+                ct.relname as tblname, ct.relnamespace, ic.idxname, ic.attpos, ic.indkey,
+                ic.indkey[ic.attpos], ic.reltuples, ic.relpages, ic.tbloid, ic.idxoid, ic.fillfactor,
+                coalesce(a1.attnum, a2.attnum) as attnum,
+                coalesce(a1.attname, a2.attname) as attname,
+                coalesce(a1.atttypid, a2.atttypid) as atttypid,
+                case when a1.attnum is null then ic.idxname else ct.relname end as attrelname
+              from (
+                select
+                  idxname, reltuples, relpages, tbloid, idxoid, fillfactor,
+                  indkey, generate_subscripts(indkey, 1) as attpos
+                from (
+                  select
+                    ci.relname as idxname, ci.reltuples, ci.relpages, i.indrelid as tbloid,
+                    i.indexrelid as idxoid,
+                    coalesce(substring(array_to_string(ci.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 90) as fillfactor,
+                    i.indkey
+                  from pg_index as i
+                    join pg_class as ci on ci.oid = i.indexrelid
+                    join pg_namespace as ns on ns.oid = ci.relnamespace
+                    join pg_am as am on am.oid = ci.relam
+                  where am.amname = 'btree'
+                    and ci.relpages > 0
+                    and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
+                ) as idx_data
+              ) as ic
+                join pg_class as ct on ct.oid = ic.tbloid
+                left join pg_attribute as a1 on a1.attrelid = ic.idxoid and a1.attnum = ic.indkey[ic.attpos]
+                left join pg_attribute as a2 on a2.attrelid = ic.tbloid and a2.attnum = ic.indkey[ic.attpos]
+            ) as i
+              join pg_namespace as n on n.oid = i.relnamespace
+              left join pg_stats as s on s.schemaname = n.nspname
+                and s.tablename = i.attrelname and s.attname = i.attname
+            group by n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor
+          ) as rows_data_stats
+        ) as rows_hdr_pdg_stats
+      ) as relation_stats
+      where relpages > 0 and (bs * relpages) >= 1024 * 1024  -- exclude indexes < 1 MiB
+      order by bloat_size_bytes desc
+      limit 100
+    `);
+    bloatData = result.rows;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F005] Error estimating index bloat: ${errorMsg}`);
+    bloatError = errorMsg;
+  }
+  report.results[nodeName] = {
+    data: {
+      indexes: bloatData,
+      ...bloatError && { error: bloatError }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 async function generateG001(client, nodeName) {
   const report = createBaseReport("G001", "Memory-related settings", nodeName);
   const postgresVersion = await getPostgresVersion(client);
@@ -27872,6 +28084,64 @@ async function generateG001(client, nodeName) {
   };
   return report;
 }
+async function generateG003(client, nodeName) {
+  const report = createBaseReport("G003", "Timeouts, locks, deadlocks", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10) || 16;
+  const allSettings = await getSettings(client, pgMajorVersion);
+  const lockTimeoutSettingNames = [
+    "lock_timeout",
+    "statement_timeout",
+    "idle_in_transaction_session_timeout",
+    "idle_session_timeout",
+    "deadlock_timeout",
+    "max_locks_per_transaction",
+    "max_pred_locks_per_transaction",
+    "max_pred_locks_per_relation",
+    "max_pred_locks_per_page",
+    "log_lock_waits",
+    "transaction_timeout"
+  ];
+  const lockSettings = {};
+  for (const name of lockTimeoutSettingNames) {
+    if (allSettings[name]) {
+      lockSettings[name] = allSettings[name];
+    }
+  }
+  let deadlockStats = null;
+  let deadlockError = null;
+  try {
+    const statsResult = await client.query(`
+      select
+        coalesce(sum(deadlocks), 0)::bigint as deadlocks,
+        coalesce(sum(conflicts), 0)::bigint as conflicts,
+        min(stats_reset)::text as stats_reset
+      from pg_stat_database
+      where datname = current_database()
+    `);
+    if (statsResult.rows.length > 0) {
+      const row = statsResult.rows[0];
+      deadlockStats = {
+        deadlocks: parseInt(row.deadlocks, 10),
+        conflicts: parseInt(row.conflicts, 10),
+        stats_reset: row.stats_reset || null
+      };
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[G003] Error querying deadlock stats: ${errorMsg}`);
+    deadlockError = errorMsg;
+  }
+  report.results[nodeName] = {
+    data: {
+      settings: lockSettings,
+      deadlock_stats: deadlockStats,
+      ...deadlockError && { deadlock_stats_error: deadlockError }
+    },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 var REPORT_GENERATORS = {
   A002: generateA002,
   A003: generateA003,
@@ -27881,7 +28151,10 @@ var REPORT_GENERATORS = {
   D001: generateD001,
   D004: generateD004,
   F001: generateF001,
+  F004: generateF004,
+  F005: generateF005,
   G001: generateG001,
+  G003: generateG003,
   H001: generateH001,
   H002: generateH002,
   H004: generateH004
@@ -27914,7 +28187,7 @@ async function generateAllReports(client, nodeName = "node-01", onProgress) {
 }
 
 // lib/checkup-dictionary.ts
-var dictionaryByCode2 = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code, entry]));
+var dictionaryByCode2 = new Map(CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code.toUpperCase(), entry]));
 function getCheckupEntry(code) {
   return dictionaryByCode2.get(code.toUpperCase()) ?? null;
 }

package/lib/checkup-dictionary.ts

@@ -32,9 +32,10 @@ export interface CheckupDictionaryEntry {
 /**
  * Module-level cache for O(1) lookups by code.
  * Initialized at module load time from embedded data.
+ * Keys are normalized to uppercase for case-insensitive lookups.
  */
 const dictionaryByCode: Map<string, CheckupDictionaryEntry> = new Map(
-  CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code, entry])
+  CHECKUP_DICTIONARY_DATA.map((entry) => [entry.code.toUpperCase(), entry])
 );
 
 /**
@@ -49,7 +50,7 @@ export function getAllCheckupEntries(): CheckupDictionaryEntry[] {
 /**
  * Get a checkup dictionary entry by its code.
  *
- * @param code - The check code (e.g., "A001", "H002")
+ * @param code - The check code (e.g., "A001", "H002"). Lookup is case-insensitive.
  * @returns The dictionary entry or null if not found
  */
 export function getCheckupEntry(code: string): CheckupDictionaryEntry | null {

package/lib/checkup.ts

@@ -1242,6 +1242,272 @@ async function generateF001(client: Client, nodeName: string): Promise<Report> {
   return report;
 }
 
+/**
+ * Generate F004 report - Autovacuum: heap bloat estimate
+ *
+ * Estimates table bloat based on statistical analysis of table pages vs expected pages.
+ * Uses pg_stats for column statistics to estimate row sizes.
+ */
+async function generateF004(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("F004", "Autovacuum: heap bloat estimate", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+
+  interface TableBloatRow {
+    schemaname: string;
+    tblname: string;
+    real_size_bytes: string;
+    real_size_pretty: string;
+    extra_size_bytes: string;
+    extra_size_pretty: string;
+    extra_pct: string;
+    fillfactor: string;
+    bloat_size_bytes: string;
+    bloat_size_pretty: string;
+    bloat_pct: string;
+    is_na: string;
+  }
+
+  let bloatData: TableBloatRow[] = [];
+  let bloatError: string | null = null;
+
+  try {
+    const result = await client.query<TableBloatRow>(`
+      select
+        schemaname,
+        tblname,
+        (bs * tblpages)::bigint as real_size_bytes,
+        pg_size_pretty((bs * tblpages)::bigint) as real_size_pretty,
+        ((tblpages - est_tblpages) * bs)::bigint as extra_size_bytes,
+        pg_size_pretty(((tblpages - est_tblpages) * bs)::bigint) as extra_size_pretty,
+        case when tblpages > 0 and tblpages - est_tblpages > 0
+          then round(100.0 * (tblpages - est_tblpages) / tblpages, 2)
+          else 0
+        end as extra_pct,
+        fillfactor,
+        case when tblpages - est_tblpages_ff > 0
+          then ((tblpages - est_tblpages_ff) * bs)::bigint
+          else 0
+        end as bloat_size_bytes,
+        pg_size_pretty(case when tblpages - est_tblpages_ff > 0
+          then ((tblpages - est_tblpages_ff) * bs)::bigint
+          else 0
+        end) as bloat_size_pretty,
+        case when tblpages > 0 and tblpages - est_tblpages_ff > 0
+          then round(100.0 * (tblpages - est_tblpages_ff) / tblpages, 2)
+          else 0
+        end as bloat_pct,
+        is_na::text
+      from (
+        select
+          ceil(reltuples / ((bs - page_hdr) / tpl_size)) + ceil(toasttuples / 4) as est_tblpages,
+          ceil(reltuples / ((bs - page_hdr) * fillfactor / (tpl_size * 100))) + ceil(toasttuples / 4) as est_tblpages_ff,
+          tblpages, fillfactor, bs, schemaname, tblname, is_na
+        from (
+          select
+            (4 + tpl_hdr_size + tpl_data_size + (2 * ma)
+              - case when tpl_hdr_size % ma = 0 then ma else tpl_hdr_size % ma end
+              - case when ceil(tpl_data_size)::int % ma = 0 then ma else ceil(tpl_data_size)::int % ma end
+            ) as tpl_size,
+            (heappages + toastpages) as tblpages,
+            reltuples, toasttuples, bs, page_hdr, schemaname, tblname, fillfactor, is_na
+          from (
+            select
+              ns.nspname as schemaname,
+              tbl.relname as tblname,
+              tbl.reltuples,
+              tbl.relpages as heappages,
+              coalesce(toast.relpages, 0) as toastpages,
+              coalesce(toast.reltuples, 0) as toasttuples,
+              coalesce(substring(array_to_string(tbl.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 100) as fillfactor,
+              current_setting('block_size')::numeric as bs,
+              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as ma,
+              24 as page_hdr,
+              23 + case when max(coalesce(s.null_frac, 0)) > 0 then (7 + count(s.attname)) / 8 else 0::int end
+                + case when bool_or(att.attname = 'oid' and att.attnum < 0) then 4 else 0 end as tpl_hdr_size,
+              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 0)) as tpl_data_size,
+              (bool_or(att.atttypid = 'pg_catalog.name'::regtype)
+                or sum(case when att.attnum > 0 then 1 else 0 end) <> count(s.attname))::int as is_na
+            from pg_attribute as att
+              join pg_class as tbl on att.attrelid = tbl.oid
+              join pg_namespace as ns on ns.oid = tbl.relnamespace
+              left join pg_stats as s on s.schemaname = ns.nspname
+                and s.tablename = tbl.relname and s.attname = att.attname
+              left join pg_class as toast on tbl.reltoastrelid = toast.oid
+            where not att.attisdropped
+              and tbl.relkind in ('r', 'm')
+              and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
+            group by ns.nspname, tbl.relname, tbl.reltuples, tbl.relpages, toast.relpages, toast.reltuples, tbl.reloptions
+          ) as s
+        ) as s2
+      ) as s3
+      where tblpages > 0 and (bs * tblpages) >= 1024 * 1024  -- exclude tables < 1 MiB
+      order by bloat_size_bytes desc
+      limit 100
+    `);
+    bloatData = result.rows;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F004] Error estimating table bloat: ${errorMsg}`);
+    bloatError = errorMsg;
+  }
+
+  report.results[nodeName] = {
+    data: {
+      tables: bloatData,
+      ...(bloatError && { error: bloatError }),
+    },
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
+/**
+ * Generate F005 report - Autovacuum: index bloat estimate
+ *
+ * Estimates B-tree index bloat based on statistical analysis of index pages vs expected pages.
+ */
+async function generateF005(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("F005", "Autovacuum: index bloat estimate", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+
+  interface IndexBloatRow {
+    schemaname: string;
+    tblname: string;
+    idxname: string;
+    real_size_bytes: string;
+    real_size_pretty: string;
+    table_size_bytes: string;
+    table_size_pretty: string;
+    extra_size_bytes: string;
+    extra_size_pretty: string;
+    extra_pct: string;
+    fillfactor: string;
+    bloat_size_bytes: string;
+    bloat_size_pretty: string;
+    bloat_pct: string;
+    is_na: string;
+  }
+
+  let bloatData: IndexBloatRow[] = [];
+  let bloatError: string | null = null;
+
+  try {
+    const result = await client.query<IndexBloatRow>(`
+      select
+        nspname as schemaname,
+        tblname,
+        idxname,
+        (bs * relpages)::bigint as real_size_bytes,
+        pg_size_pretty((bs * relpages)::bigint) as real_size_pretty,
+        pg_relation_size(tbloid)::bigint as table_size_bytes,
+        pg_size_pretty(pg_relation_size(tbloid)) as table_size_pretty,
+        ((relpages - est_pages) * bs)::bigint as extra_size_bytes,
+        pg_size_pretty(((relpages - est_pages) * bs)::bigint) as extra_size_pretty,
+        round(100.0 * (relpages - est_pages) / relpages, 2) as extra_pct,
+        fillfactor,
+        case when relpages > est_pages_ff
+          then ((relpages - est_pages_ff) * bs)::bigint
+          else 0
+        end as bloat_size_bytes,
+        pg_size_pretty(case when relpages > est_pages_ff
+          then ((relpages - est_pages_ff) * bs)::bigint
+          else 0
+        end) as bloat_size_pretty,
+        case when relpages > est_pages_ff
+          then round(100.0 * (relpages - est_pages_ff) / relpages, 2)
+          else 0
+        end as bloat_pct,
+        is_na::text
+      from (
+        select
+          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) / (4 + nulldatahdrwidth)::float)), 0) as est_pages,
+          coalesce(1 + ceil(reltuples / floor((bs - pageopqdata - pagehdr) * fillfactor / (100 * (4 + nulldatahdrwidth)::float))), 0) as est_pages_ff,
+          bs, nspname, tblname, idxname, relpages, fillfactor, is_na, tbloid
+        from (
+          select
+            maxalign, bs, nspname, tblname, idxname, reltuples, relpages, idxoid, fillfactor, tbloid,
+            (index_tuple_hdr_bm + maxalign
+              - case when index_tuple_hdr_bm % maxalign = 0 then maxalign else index_tuple_hdr_bm % maxalign end
+              + nulldatawidth + maxalign
+              - case when nulldatawidth = 0 then 0
+                     when nulldatawidth::integer % maxalign = 0 then maxalign
+                     else nulldatawidth::integer % maxalign end
+            )::numeric as nulldatahdrwidth,
+            pagehdr, pageopqdata, is_na
+          from (
+            select
+              n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor,
+              current_setting('block_size')::numeric as bs,
+              case when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as maxalign,
+              24 as pagehdr,
+              16 as pageopqdata,
+              case when max(coalesce(s.null_frac, 0)) = 0
+                then 8
+                else 8 + ((32 + 8 - 1) / 8)
+              end as index_tuple_hdr_bm,
+              sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 1024)) as nulldatawidth,
+              (max(case when i.atttypid = 'pg_catalog.name'::regtype then 1 else 0 end) > 0)::int as is_na
+            from (
+              select
+                ct.relname as tblname, ct.relnamespace, ic.idxname, ic.attpos, ic.indkey,
+                ic.indkey[ic.attpos], ic.reltuples, ic.relpages, ic.tbloid, ic.idxoid, ic.fillfactor,
+                coalesce(a1.attnum, a2.attnum) as attnum,
+                coalesce(a1.attname, a2.attname) as attname,
+                coalesce(a1.atttypid, a2.atttypid) as atttypid,
+                case when a1.attnum is null then ic.idxname else ct.relname end as attrelname
+              from (
+                select
+                  idxname, reltuples, relpages, tbloid, idxoid, fillfactor,
+                  indkey, generate_subscripts(indkey, 1) as attpos
+                from (
+                  select
+                    ci.relname as idxname, ci.reltuples, ci.relpages, i.indrelid as tbloid,
+                    i.indexrelid as idxoid,
+                    coalesce(substring(array_to_string(ci.reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 90) as fillfactor,
+                    i.indkey
+                  from pg_index as i
+                    join pg_class as ci on ci.oid = i.indexrelid
+                    join pg_namespace as ns on ns.oid = ci.relnamespace
+                    join pg_am as am on am.oid = ci.relam
+                  where am.amname = 'btree'
+                    and ci.relpages > 0
+                    and ns.nspname not in ('pg_catalog', 'information_schema', 'pg_toast')
+                ) as idx_data
+              ) as ic
+                join pg_class as ct on ct.oid = ic.tbloid
+                left join pg_attribute as a1 on a1.attrelid = ic.idxoid and a1.attnum = ic.indkey[ic.attpos]
+                left join pg_attribute as a2 on a2.attrelid = ic.tbloid and a2.attnum = ic.indkey[ic.attpos]
+            ) as i
+              join pg_namespace as n on n.oid = i.relnamespace
+              left join pg_stats as s on s.schemaname = n.nspname
+                and s.tablename = i.attrelname and s.attname = i.attname
+            group by n.nspname, i.tblname, i.idxname, i.reltuples, i.relpages, i.tbloid, i.idxoid, i.fillfactor
+          ) as rows_data_stats
+        ) as rows_hdr_pdg_stats
+      ) as relation_stats
+      where relpages > 0 and (bs * relpages) >= 1024 * 1024  -- exclude indexes < 1 MiB
+      order by bloat_size_bytes desc
+      limit 100
+    `);
+    bloatData = result.rows;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F005] Error estimating index bloat: ${errorMsg}`);
+    bloatError = errorMsg;
+  }
+
+  report.results[nodeName] = {
+    data: {
+      indexes: bloatData,
+      ...(bloatError && { error: bloatError }),
+    },
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
 /**
  * Generate G001 report - Memory-related settings
  */
@@ -1358,6 +1624,82 @@ async function generateG001(client: Client, nodeName: string): Promise<Report> {
   return report;
 }
 
+/**
+ * Generate G003 report - Timeouts, locks, deadlocks
+ *
+ * Collects timeout and lock-related settings, plus deadlock statistics.
+ */
+async function generateG003(client: Client, nodeName: string): Promise<Report> {
+  const report = createBaseReport("G003", "Timeouts, locks, deadlocks", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10) || 16;
+  const allSettings = await getSettings(client, pgMajorVersion);
+
+  // Timeout and lock-related setting names
+  const lockTimeoutSettingNames = [
+    "lock_timeout",
+    "statement_timeout",
+    "idle_in_transaction_session_timeout",
+    "idle_session_timeout",
+    "deadlock_timeout",
+    "max_locks_per_transaction",
+    "max_pred_locks_per_transaction",
+    "max_pred_locks_per_relation",
+    "max_pred_locks_per_page",
+    "log_lock_waits",
+    "transaction_timeout",
+  ];
+
+  const lockSettings: Record<string, SettingInfo> = {};
+  for (const name of lockTimeoutSettingNames) {
+    if (allSettings[name]) {
+      lockSettings[name] = allSettings[name];
+    }
+  }
+
+  // Get deadlock statistics from pg_stat_database
+  let deadlockStats: {
+    deadlocks: number;
+    conflicts: number;
+    stats_reset: string | null;
+  } | null = null;
+  let deadlockError: string | null = null;
+
+  try {
+    const statsResult = await client.query(`
+      select
+        coalesce(sum(deadlocks), 0)::bigint as deadlocks,
+        coalesce(sum(conflicts), 0)::bigint as conflicts,
+        min(stats_reset)::text as stats_reset
+      from pg_stat_database
+      where datname = current_database()
+    `);
+    if (statsResult.rows.length > 0) {
+      const row = statsResult.rows[0];
+      deadlockStats = {
+        deadlocks: parseInt(row.deadlocks, 10),
+        conflicts: parseInt(row.conflicts, 10),
+        stats_reset: row.stats_reset || null,
+      };
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[G003] Error querying deadlock stats: ${errorMsg}`);
+    deadlockError = errorMsg;
+  }
+
+  report.results[nodeName] = {
+    data: {
+      settings: lockSettings,
+      deadlock_stats: deadlockStats,
+      ...(deadlockError && { deadlock_stats_error: deadlockError }),
+    },
+    postgres_version: postgresVersion,
+  };
+
+  return report;
+}
+
 /**
  * Available report generators
  */
@@ -1370,7 +1712,10 @@ export const REPORT_GENERATORS: Record<string, (client: Client, nodeName: string
   D001: generateD001,
   D004: generateD004,
   F001: generateF001,
+  F004: generateF004,
+  F005: generateF005,
   G001: generateG001,
+  G003: generateG003,
   H001: generateH001,
   H002: generateH002,
   H004: generateH004,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresai",
-  "version": "0.14.0-dev.80",
+  "version": "0.14.0-dev.82",
   "description": "postgres_ai CLI",
   "license": "Apache-2.0",
   "private": false,
@@ -34,7 +34,7 @@
     "start:node": "node ./dist/bin/postgres-ai.js --help",
     "dev": "bun run embed-all && bun --watch ./bin/postgres-ai.ts",
     "test": "bun run embed-all && bun test",
-    "test:fast": "bun run embed-all && bun test",
+    "test:fast": "bun run embed-all && bun test --coverage=false",
     "test:coverage": "bun run embed-all && bun test --coverage && echo 'Coverage report: cli/coverage/lcov-report/index.html'",
     "typecheck": "bun run embed-all && bunx tsc --noEmit"
   },

package/test/checkup.test.ts

@@ -86,7 +86,7 @@ describe("createBaseReport", () => {
 // Tests for CHECK_INFO
 describe("CHECK_INFO and REPORT_GENERATORS", () => {
   // Express-mode checks that have generators
-  const expressCheckIds = ["A002", "A003", "A004", "A007", "A013", "D001", "D004", "F001", "G001", "H001", "H002", "H004"];
+  const expressCheckIds = ["A002", "A003", "A004", "A007", "A013", "D001", "D004", "F001", "F004", "F005", "G001", "G003", "H001", "H002", "H004"];
 
   test("CHECK_INFO contains all express-mode checks", () => {
     for (const checkId of expressCheckIds) {