postgresai 0.14.0-dev.50 → 0.14.0-dev.52

package/dist/bin/postgres-ai.js

@@ -13064,7 +13064,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.14.0-dev.50",
+  version: "0.14.0-dev.52",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -13086,7 +13086,7 @@ var package_default = {
     node: ">=18"
   },
   scripts: {
-    build: `bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))"`,
+    build: `bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r sql dist/`,
     prepublishOnly: "npm run build",
     start: "bun ./bin/postgres-ai.ts --help",
     "start:node": "node ./dist/bin/postgres-ai.js --help",
@@ -13104,8 +13104,6 @@ var package_default = {
     "@types/bun": "^1.1.14",
     "@types/js-yaml": "^4.0.9",
     "@types/pg": "^8.15.6",
-    ajv: "^8.17.1",
-    "ajv-formats": "^3.0.1",
     typescript: "^5.3.3"
   },
   publishConfig: {
@@ -13131,8 +13129,7 @@ function readConfig() {
   const config = {
     apiKey: null,
     baseUrl: null,
-    orgId: null,
-    defaultProject: null
+    orgId: null
   };
   const userConfigPath = getConfigPath();
   if (fs.existsSync(userConfigPath)) {
@@ -13142,7 +13139,6 @@ function readConfig() {
       config.apiKey = parsed.apiKey || null;
       config.baseUrl = parsed.baseUrl || null;
       config.orgId = parsed.orgId || null;
-      config.defaultProject = parsed.defaultProject || null;
       return config;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -15862,10 +15858,9 @@ var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
 // bin/postgres-ai.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as os3 from "os";
-import * as crypto2 from "crypto";
 
 // node_modules/pg/esm/index.mjs
 var import_lib = __toESM(require_lib2(), 1);
@@ -15881,10 +15876,9 @@ 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.50";
 var package_default2 = {
   name: "postgresai",
-  version,
+  version: "0.14.0-dev.52",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -15906,7 +15900,7 @@ var package_default2 = {
     node: ">=18"
   },
   scripts: {
-    build: `bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))"`,
+    build: `bun build ./bin/postgres-ai.ts --outdir ./dist/bin --target node && node -e "const fs=require('fs');const f='./dist/bin/postgres-ai.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env bun','#!/usr/bin/env node'))" && cp -r sql dist/`,
     prepublishOnly: "npm run build",
     start: "bun ./bin/postgres-ai.ts --help",
     "start:node": "node ./dist/bin/postgres-ai.js --help",
@@ -15924,8 +15918,6 @@ var package_default2 = {
     "@types/bun": "^1.1.14",
     "@types/js-yaml": "^4.0.9",
     "@types/pg": "^8.15.6",
-    ajv: "^8.17.1",
-    "ajv-formats": "^3.0.1",
     typescript: "^5.3.3"
   },
   publishConfig: {
@@ -15951,8 +15943,7 @@ function readConfig2() {
   const config = {
     apiKey: null,
     baseUrl: null,
-    orgId: null,
-    defaultProject: null
+    orgId: null
   };
   const userConfigPath = getConfigPath2();
   if (fs2.existsSync(userConfigPath)) {
@@ -15962,7 +15953,6 @@ function readConfig2() {
       config.apiKey = parsed.apiKey || null;
       config.baseUrl = parsed.baseUrl || null;
       config.orgId = parsed.orgId || null;
-      config.defaultProject = parsed.defaultProject || null;
       return config;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -17114,10 +17104,10 @@ var ksuid = /^[A-Za-z0-9]{27}$/;
 var nanoid = /^[a-zA-Z0-9_-]{21}$/;
 var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
 var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-var uuid = (version2) => {
-  if (!version2)
+var uuid = (version) => {
+  if (!version)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 };
 var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
 var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
@@ -17586,7 +17576,7 @@ class Doc {
 }
 
 // node_modules/zod/v4/core/versions.js
-var version2 = {
+var version = {
   major: 4,
   minor: 2,
   patch: 1
@@ -17598,7 +17588,7 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   inst ?? (inst = {});
   inst._zod.def = def;
   inst._zod.bag = inst._zod.bag || {};
-  inst._zod.version = version2;
+  inst._zod.version = version;
   const checks = [...inst._zod.def.checks ?? []];
   if (inst._zod.traits.has("$ZodCheck")) {
     checks.unshift(inst);
@@ -24054,6 +24044,7 @@ function generatePKCEParams() {
 }
 
 // lib/auth-server.ts
+import * as http from "http";
 function escapeHtml(str2) {
   if (!str2)
     return "";
@@ -24069,36 +24060,42 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
     resolveCallback = resolve4;
     rejectCallback = reject;
   });
+  const stopServer = () => {
+    if (serverInstance) {
+      serverInstance.close();
+      serverInstance = null;
+    }
+  };
   const timeout = setTimeout(() => {
     if (!resolved) {
       resolved = true;
-      if (serverInstance) {
-        serverInstance.stop();
-      }
+      stopServer();
       rejectCallback(new Error("Authentication timeout. Please try again."));
     }
   }, timeoutMs);
-  serverInstance = Bun.serve({
-    port,
-    hostname: "127.0.0.1",
-    fetch(req) {
-      if (resolved) {
-        return new Response("Already handled", { status: 200 });
-      }
-      const url = new URL(req.url);
-      if (!url.pathname.startsWith("/callback")) {
-        return new Response("Not Found", { status: 404 });
-      }
-      const code = url.searchParams.get("code");
-      const state = url.searchParams.get("state");
-      const error2 = url.searchParams.get("error");
-      const errorDescription = url.searchParams.get("error_description");
-      if (error2) {
-        resolved = true;
-        clearTimeout(timeout);
-        setTimeout(() => serverInstance?.stop(), 100);
-        rejectCallback(new Error(`OAuth error: ${error2}${errorDescription ? ` - ${errorDescription}` : ""}`));
-        return new Response(`
+  serverInstance = http.createServer((req, res) => {
+    if (resolved) {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("Already handled");
+      return;
+    }
+    const url = new URL(req.url || "/", `http://127.0.0.1:${actualPort}`);
+    if (!url.pathname.startsWith("/callback")) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    const error2 = url.searchParams.get("error");
+    const errorDescription = url.searchParams.get("error_description");
+    if (error2) {
+      resolved = true;
+      clearTimeout(timeout);
+      setTimeout(() => stopServer(), 100);
+      rejectCallback(new Error(`OAuth error: ${error2}${errorDescription ? ` - ${errorDescription}` : ""}`));
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -24119,10 +24116,12 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
   </div>
 </body>
 </html>
-        `, { status: 400, headers: { "Content-Type": "text/html" } });
-      }
-      if (!code || !state) {
-        return new Response(`
+      `);
+      return;
+    }
+    if (!code || !state) {
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -24141,14 +24140,16 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
   </div>
 </body>
 </html>
-        `, { status: 400, headers: { "Content-Type": "text/html" } });
-      }
-      if (expectedState && state !== expectedState) {
-        resolved = true;
-        clearTimeout(timeout);
-        setTimeout(() => serverInstance?.stop(), 100);
-        rejectCallback(new Error("State mismatch (possible CSRF attack)"));
-        return new Response(`
+      `);
+      return;
+    }
+    if (expectedState && state !== expectedState) {
+      resolved = true;
+      clearTimeout(timeout);
+      setTimeout(() => stopServer(), 100);
+      rejectCallback(new Error("State mismatch (possible CSRF attack)"));
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -24167,13 +24168,15 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
   </div>
 </body>
 </html>
-        `, { status: 400, headers: { "Content-Type": "text/html" } });
-      }
-      resolved = true;
-      clearTimeout(timeout);
-      resolveCallback({ code, state });
-      setTimeout(() => serverInstance?.stop(), 100);
-      return new Response(`
+      `);
+      return;
+    }
+    resolved = true;
+    clearTimeout(timeout);
+    resolveCallback({ code, state });
+    setTimeout(() => stopServer(), 100);
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(`
 <!DOCTYPE html>
 <html>
 <head>
@@ -24192,12 +24195,16 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
   </div>
 </body>
 </html>
-      `, { status: 200, headers: { "Content-Type": "text/html" } });
+    `);
+  });
+  serverInstance.listen(port, "127.0.0.1", () => {
+    const address = serverInstance?.address();
+    if (address && typeof address === "object") {
+      actualPort = address.port;
     }
   });
-  actualPort = serverInstance.port;
   return {
-    server: { stop: () => serverInstance?.stop() },
+    server: { stop: stopServer },
     promise: promise2,
     getPort: () => actualPort
   };
@@ -24206,1299 +24213,6 @@ function createCallbackServer(port = 0, expectedState = null, timeoutMs = 300000
 // bin/postgres-ai.ts
 import { createInterface } from "readline";
 import * as childProcess from "child_process";
-
-// lib/checkup.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-
-// lib/metrics-loader.ts
-var EMBEDDED_SQL = {
-  express_version: `
-select
-  name,
-  setting
-from pg_settings
-where name in ('server_version', 'server_version_num');
-`,
-  express_settings: `
-select
-  name,
-  setting,
-  unit,
-  category,
-  context,
-  vartype,
-  case when (source <> 'default') then 0 else 1 end as is_default,
-  case
-    when unit = '8kB' then pg_size_pretty(setting::bigint * 8192)
-    when unit = 'kB' then pg_size_pretty(setting::bigint * 1024)
-    when unit = 'MB' then pg_size_pretty(setting::bigint * 1024 * 1024)
-    when unit = 'B' then pg_size_pretty(setting::bigint)
-    when unit = 'ms' then setting || ' ms'
-    when unit = 's' then setting || ' s'
-    when unit = 'min' then setting || ' min'
-    else setting
-  end as pretty_value
-from pg_settings
-order by name;
-`,
-  express_altered_settings: `
-select
-  name,
-  setting,
-  unit,
-  category,
-  case
-    when unit = '8kB' then pg_size_pretty(setting::bigint * 8192)
-    when unit = 'kB' then pg_size_pretty(setting::bigint * 1024)
-    when unit = 'MB' then pg_size_pretty(setting::bigint * 1024 * 1024)
-    when unit = 'B' then pg_size_pretty(setting::bigint)
-    when unit = 'ms' then setting || ' ms'
-    when unit = 's' then setting || ' s'
-    when unit = 'min' then setting || ' min'
-    else setting
-  end as pretty_value
-from pg_settings
-where source <> 'default'
-order by name;
-`,
-  express_database_sizes: `
-select
-  datname,
-  pg_database_size(datname) as size_bytes
-from pg_database
-where datistemplate = false
-order by size_bytes desc;
-`,
-  express_cluster_stats: `
-select
-  sum(numbackends) as total_connections,
-  sum(xact_commit) as total_commits,
-  sum(xact_rollback) as total_rollbacks,
-  sum(blks_read) as blocks_read,
-  sum(blks_hit) as blocks_hit,
-  sum(tup_returned) as tuples_returned,
-  sum(tup_fetched) as tuples_fetched,
-  sum(tup_inserted) as tuples_inserted,
-  sum(tup_updated) as tuples_updated,
-  sum(tup_deleted) as tuples_deleted,
-  sum(deadlocks) as total_deadlocks,
-  sum(temp_files) as temp_files_created,
-  sum(temp_bytes) as temp_bytes_written
-from pg_stat_database
-where datname is not null;
-`,
-  express_connection_states: `
-select
-  coalesce(state, 'null') as state,
-  count(*) as count
-from pg_stat_activity
-group by state;
-`,
-  express_uptime: `
-select
-  pg_postmaster_start_time() as start_time,
-  current_timestamp - pg_postmaster_start_time() as uptime;
-`,
-  express_stats_reset: `
-select
-  extract(epoch from stats_reset) as stats_reset_epoch,
-  stats_reset::text as stats_reset_time,
-  extract(day from (now() - stats_reset))::integer as days_since_reset,
-  extract(epoch from pg_postmaster_start_time()) as postmaster_startup_epoch,
-  pg_postmaster_start_time()::text as postmaster_startup_time
-from pg_stat_database
-where datname = current_database();
-`,
-  express_current_database: `
-select
-  current_database() as datname,
-  pg_database_size(current_database()) as size_bytes;
-`,
-  pg_invalid_indexes: `
-with fk_indexes as (
-  select
-    schemaname as tag_schema_name,
-    (indexrelid::regclass)::text as tag_index_name,
-    (relid::regclass)::text as tag_table_name,
-    (confrelid::regclass)::text as tag_fk_table_ref,
-    array_to_string(indclass, ', ') as tag_opclasses
-  from
-    pg_stat_all_indexes
-  join pg_index using (indexrelid)
-  left join pg_constraint
-    on array_to_string(indkey, ',') = array_to_string(conkey, ',')
-      and schemaname = (connamespace::regnamespace)::text
-      and conrelid = relid
-      and contype = 'f'
-  where idx_scan = 0
-    and indisunique is false
-    and conkey is not null
-), data as (
-  select
-    pci.relname as tag_index_name,
-    pn.nspname as tag_schema_name,
-    pct.relname as tag_table_name,
-    quote_ident(pn.nspname) as tag_schema_name,
-    quote_ident(pci.relname) as tag_index_name,
-    quote_ident(pct.relname) as tag_table_name,
-    coalesce(nullif(quote_ident(pn.nspname), 'public') || '.', '') || quote_ident(pct.relname) as tag_relation_name,
-    pg_relation_size(pidx.indexrelid) index_size_bytes,
-    ((
-      select count(1)
-      from fk_indexes fi
-      where
-        fi.tag_fk_table_ref = pct.relname
-        and fi.tag_opclasses like (array_to_string(pidx.indclass, ', ') || '%')
-    ) > 0)::int as supports_fk
-  from pg_index pidx
-  join pg_class as pci on pci.oid = pidx.indexrelid
-  join pg_class as pct on pct.oid = pidx.indrelid
-  left join pg_namespace pn on pn.oid = pct.relnamespace
-  where pidx.indisvalid = false
-), data_total as (
-    select
-      sum(index_size_bytes) as index_size_bytes_sum
-    from data
-), num_data as (
-  select
-    row_number() over () num,
-    data.*
-  from data
-)
-select
-  (extract(epoch from now()) * 1e9)::int8 as epoch_ns,
-  current_database() as tag_datname,
-  num_data.*
-from num_data
-limit 1000;
-`,
-  unused_indexes: `
-with fk_indexes as (
-  select
-    n.nspname as schema_name,
-    ci.relname as index_name,
-    cr.relname as table_name,
-    (confrelid::regclass)::text as fk_table_ref,
-    array_to_string(indclass, ', ') as opclasses
-  from pg_index i
-  join pg_class ci on ci.oid = i.indexrelid and ci.relkind = 'i'
-  join pg_class cr on cr.oid = i.indrelid and cr.relkind = 'r'
-  join pg_namespace n on n.oid = ci.relnamespace
-  join pg_constraint cn on cn.conrelid = cr.oid
-  left join pg_stat_all_indexes as si on si.indexrelid = i.indexrelid
-  where
-    contype = 'f'
-    and i.indisunique is false
-    and conkey is not null
-    and ci.relpages > 5
-    and si.idx_scan < 10
-), table_scans as (
-  select relid,
-      tables.idx_scan + tables.seq_scan as all_scans,
-      ( tables.n_tup_ins + tables.n_tup_upd + tables.n_tup_del ) as writes,
-    pg_relation_size(relid) as table_size
-      from pg_stat_all_tables as tables
-      join pg_class c on c.oid = relid
-      where c.relpages > 5
-), indexes as (
-  select
-    i.indrelid,
-    i.indexrelid,
-    n.nspname as schema_name,
-    cr.relname as table_name,
-    ci.relname as index_name,
-    si.idx_scan,
-    pg_relation_size(i.indexrelid) as index_bytes,
-    ci.relpages,
-    (case when a.amname = 'btree' then true else false end) as idx_is_btree,
-    array_to_string(i.indclass, ', ') as opclasses
-  from pg_index i
-    join pg_class ci on ci.oid = i.indexrelid and ci.relkind = 'i'
-    join pg_class cr on cr.oid = i.indrelid and cr.relkind = 'r'
-    join pg_namespace n on n.oid = ci.relnamespace
-    join pg_am a on ci.relam = a.oid
-    left join pg_stat_all_indexes as si on si.indexrelid = i.indexrelid
-  where
-    i.indisunique = false
-    and i.indisvalid = true
-    and ci.relpages > 5
-), index_ratios as (
-  select
-    i.indexrelid as index_id,
-    i.schema_name,
-    i.table_name,
-    i.index_name,
-    idx_scan,
-    all_scans,
-    round(( case when all_scans = 0 then 0.0::numeric
-      else idx_scan::numeric/all_scans * 100 end), 2) as index_scan_pct,
-    writes,
-    round((case when writes = 0 then idx_scan::numeric else idx_scan::numeric/writes end), 2)
-      as scans_per_write,
-    index_bytes as index_size_bytes,
-    table_size as table_size_bytes,
-    i.relpages,
-    idx_is_btree,
-    i.opclasses,
-    (
-      select count(1)
-      from fk_indexes fi
-      where fi.fk_table_ref = i.table_name
-        and fi.schema_name = i.schema_name
-        and fi.opclasses like (i.opclasses || '%')
-    ) > 0 as supports_fk
-  from indexes i
-  join table_scans ts on ts.relid = i.indrelid
-)
-select
-  'Never Used Indexes' as tag_reason,
-  current_database() as tag_datname,
-  index_id,
-  schema_name as tag_schema_name,
-  table_name as tag_table_name,
-  index_name as tag_index_name,
-  pg_get_indexdef(index_id) as index_definition,
-  idx_scan,
-  all_scans,
-  index_scan_pct,
-  writes,
-  scans_per_write,
-  index_size_bytes,
-  table_size_bytes,
-  relpages,
-  idx_is_btree,
-  opclasses as tag_opclasses,
-  supports_fk
-from index_ratios
-where
-  idx_scan = 0
-  and idx_is_btree
-order by index_size_bytes desc
-limit 1000;
-`,
-  redundant_indexes: `
-with fk_indexes as (
-  select
-    n.nspname as schema_name,
-    ci.relname as index_name,
-    cr.relname as table_name,
-    (confrelid::regclass)::text as fk_table_ref,
-    array_to_string(indclass, ', ') as opclasses
-  from pg_index i
-  join pg_class ci on ci.oid = i.indexrelid and ci.relkind = 'i'
-  join pg_class cr on cr.oid = i.indrelid and cr.relkind = 'r'
-  join pg_namespace n on n.oid = ci.relnamespace
-  join pg_constraint cn on cn.conrelid = cr.oid
-  left join pg_stat_all_indexes as si on si.indexrelid = i.indexrelid
-  where
-    contype = 'f'
-    and i.indisunique is false
-    and conkey is not null
-    and ci.relpages > 5
-    and si.idx_scan < 10
-),
-index_data as (
-  select
-    *,
-    indkey::text as columns,
-    array_to_string(indclass, ', ') as opclasses
-  from pg_index i
-  join pg_class ci on ci.oid = i.indexrelid and ci.relkind = 'i'
-  where indisvalid = true and ci.relpages > 5
-), redundant_indexes as (
-  select
-    i2.indexrelid as index_id,
-    tnsp.nspname as schema_name,
-    trel.relname as table_name,
-    pg_relation_size(trel.oid) as table_size_bytes,
-    irel.relname as index_name,
-    am1.amname as access_method,
-    (i1.indexrelid::regclass)::text as reason,
-    i1.indexrelid as reason_index_id,
-    pg_get_indexdef(i1.indexrelid) main_index_def,
-    pg_size_pretty(pg_relation_size(i1.indexrelid)) main_index_size,
-    pg_get_indexdef(i2.indexrelid) index_def,
-    pg_relation_size(i2.indexrelid) index_size_bytes,
-    s.idx_scan as index_usage,
-    quote_ident(tnsp.nspname) as formated_schema_name,
-    coalesce(nullif(quote_ident(tnsp.nspname), 'public') || '.', '') || quote_ident(irel.relname) as formated_index_name,
-    quote_ident(trel.relname) as formated_table_name,
-    coalesce(nullif(quote_ident(tnsp.nspname), 'public') || '.', '') || quote_ident(trel.relname) as formated_relation_name,
-    i2.opclasses
-  from (
-    select indrelid, indexrelid, opclasses, indclass, indexprs, indpred, indisprimary, indisunique, columns
-      from index_data
-      order by indexrelid
-    ) as i1
-    join index_data as i2 on (
-        i1.indrelid = i2.indrelid
-        and i1.indexrelid <> i2.indexrelid
-    )
-    inner join pg_opclass op1 on i1.indclass[0] = op1.oid
-    inner join pg_opclass op2 on i2.indclass[0] = op2.oid
-    inner join pg_am am1 on op1.opcmethod = am1.oid
-    inner join pg_am am2 on op2.opcmethod = am2.oid
-    join pg_stat_all_indexes as s on s.indexrelid = i2.indexrelid
-    join pg_class as trel on trel.oid = i2.indrelid
-    join pg_namespace as tnsp on trel.relnamespace = tnsp.oid
-    join pg_class as irel on irel.oid = i2.indexrelid
-  where
-    not i2.indisprimary
-    and not i2.indisunique
-    and  am1.amname = am2.amname
-    and i1.columns like (i2.columns || '%')
-    and i1.opclasses like (i2.opclasses || '%')
-    and pg_get_expr(i1.indexprs, i1.indrelid) is not distinct from pg_get_expr(i2.indexprs, i2.indrelid)
-    and pg_get_expr(i1.indpred, i1.indrelid) is not distinct from pg_get_expr(i2.indpred, i2.indrelid)
-), redundant_indexes_fk as (
-  select
-    ri.*,
-    ((
-      select count(1)
-      from fk_indexes fi
-      where
-        fi.fk_table_ref = ri.table_name
-        and fi.opclasses like (ri.opclasses || '%')
-    ) > 0)::int as supports_fk
-  from redundant_indexes ri
-),
-redundant_indexes_tmp_num as (
-  select row_number() over () num, rig.*
-  from redundant_indexes_fk rig
-), redundant_indexes_tmp_links as (
-    select
-    ri1.*,
-    ri2.num as r_num
-    from redundant_indexes_tmp_num ri1
-    left join redundant_indexes_tmp_num ri2 on ri2.reason_index_id = ri1.index_id and ri1.reason_index_id = ri2.index_id
-), redundant_indexes_tmp_cut as (
-    select
-    *
-    from redundant_indexes_tmp_links
-    where num < r_num or r_num is null
-), redundant_indexes_cut_grouped as (
-  select
-    distinct(num),
-    *
-  from redundant_indexes_tmp_cut
-  order by index_size_bytes desc
-), redundant_indexes_grouped as (
-  select
-    index_id,
-    schema_name as tag_schema_name,
-    table_name,
-    table_size_bytes,
-    index_name as tag_index_name,
-    access_method as tag_access_method,
-    string_agg(distinct reason, ', ') as tag_reason,
-    index_size_bytes,
-    index_usage,
-    index_def as index_definition,
-    formated_index_name as tag_index_name,
-    formated_schema_name as tag_schema_name,
-    formated_table_name as tag_table_name,
-    formated_relation_name as tag_relation_name,
-    supports_fk::int as supports_fk,
-    json_agg(
-      distinct jsonb_build_object(
-        'index_name', reason,
-        'index_definition', main_index_def
-      )
-    )::text as covering_indexes_json
-  from redundant_indexes_cut_grouped
-  group by
-    index_id,
-    table_size_bytes,
-    schema_name,
-    table_name,
-    index_name,
-    access_method,
-    index_def,
-    index_size_bytes,
-    index_usage,
-    formated_index_name,
-    formated_schema_name,
-    formated_table_name,
-    formated_relation_name,
-    supports_fk
-  order by index_size_bytes desc
-)
-select * from redundant_indexes_grouped
-limit 1000;
-`
-};
-function getMetricSql(metricName, _pgMajorVersion = 16) {
-  const sql = EMBEDDED_SQL[metricName];
-  if (!sql) {
-    throw new Error(`Metric "${metricName}" not found. Available metrics: ${Object.keys(EMBEDDED_SQL).join(", ")}`);
-  }
-  return sql;
-}
-var METRIC_NAMES = {
-  H001: "pg_invalid_indexes",
-  H002: "unused_indexes",
-  H004: "redundant_indexes",
-  version: "express_version",
-  settings: "express_settings",
-  alteredSettings: "express_altered_settings",
-  databaseSizes: "express_database_sizes",
-  clusterStats: "express_cluster_stats",
-  connectionStates: "express_connection_states",
-  uptimeInfo: "express_uptime",
-  statsReset: "express_stats_reset",
-  currentDatabase: "express_current_database"
-};
-function transformMetricRow(row) {
-  const result = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (key === "epoch_ns" || key === "num" || key === "tag_datname") {
-      continue;
-    }
-    const newKey = key.startsWith("tag_") ? key.slice(4) : key;
-    result[newKey] = value;
-  }
-  return result;
-}
-
-// lib/checkup.ts
-var __dirname = "/builds/postgres-ai/postgres_ai/cli/lib";
-function parseVersionNum(versionNum) {
-  if (!versionNum || versionNum.length < 6) {
-    return { major: "", minor: "" };
-  }
-  try {
-    const num = parseInt(versionNum, 10);
-    return {
-      major: Math.floor(num / 1e4).toString(),
-      minor: (num % 1e4).toString()
-    };
-  } catch {
-    return { major: "", minor: "" };
-  }
-}
-function formatBytes(bytes) {
-  if (bytes === 0)
-    return "0 B";
-  const units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
-  const i2 = Math.floor(Math.log(bytes) / Math.log(1024));
-  return `${(bytes / Math.pow(1024, i2)).toFixed(2)} ${units[i2]}`;
-}
-async function getPostgresVersion(client) {
-  const sql = getMetricSql(METRIC_NAMES.version);
-  const result = await client.query(sql);
-  let version3 = "";
-  let serverVersionNum = "";
-  for (const row of result.rows) {
-    if (row.name === "server_version") {
-      version3 = row.setting;
-    } else if (row.name === "server_version_num") {
-      serverVersionNum = row.setting;
-    }
-  }
-  const { major, minor } = parseVersionNum(serverVersionNum);
-  return {
-    version: version3,
-    server_version_num: serverVersionNum,
-    server_major_ver: major,
-    server_minor_ver: minor
-  };
-}
-async function getSettings(client) {
-  const sql = getMetricSql(METRIC_NAMES.settings);
-  const result = await client.query(sql);
-  const settings = {};
-  for (const row of result.rows) {
-    settings[row.name] = {
-      setting: row.setting,
-      unit: row.unit || "",
-      category: row.category,
-      context: row.context,
-      vartype: row.vartype,
-      pretty_value: row.pretty_value
-    };
-  }
-  return settings;
-}
-async function getAlteredSettings(client) {
-  const sql = getMetricSql(METRIC_NAMES.alteredSettings);
-  const result = await client.query(sql);
-  const settings = {};
-  for (const row of result.rows) {
-    settings[row.name] = {
-      value: row.setting,
-      unit: row.unit || "",
-      category: row.category,
-      pretty_value: row.pretty_value
-    };
-  }
-  return settings;
-}
-async function getDatabaseSizes(client) {
-  const sql = getMetricSql(METRIC_NAMES.databaseSizes);
-  const result = await client.query(sql);
-  const sizes = {};
-  for (const row of result.rows) {
-    sizes[row.datname] = parseInt(row.size_bytes, 10);
-  }
-  return sizes;
-}
-async function getClusterInfo(client) {
-  const info = {};
-  const clusterStatsSql = getMetricSql(METRIC_NAMES.clusterStats);
-  const statsResult = await client.query(clusterStatsSql);
-  if (statsResult.rows.length > 0) {
-    const stats = statsResult.rows[0];
-    info.total_connections = {
-      value: String(stats.total_connections || 0),
-      unit: "connections",
-      description: "Total active database connections"
-    };
-    info.total_commits = {
-      value: String(stats.total_commits || 0),
-      unit: "transactions",
-      description: "Total committed transactions"
-    };
-    info.total_rollbacks = {
-      value: String(stats.total_rollbacks || 0),
-      unit: "transactions",
-      description: "Total rolled back transactions"
-    };
-    const blocksHit = parseInt(stats.blocks_hit || "0", 10);
-    const blocksRead = parseInt(stats.blocks_read || "0", 10);
-    const totalBlocks = blocksHit + blocksRead;
-    const cacheHitRatio = totalBlocks > 0 ? (blocksHit / totalBlocks * 100).toFixed(2) : "0.00";
-    info.cache_hit_ratio = {
-      value: cacheHitRatio,
-      unit: "%",
-      description: "Buffer cache hit ratio"
-    };
-    info.blocks_read = {
-      value: String(blocksRead),
-      unit: "blocks",
-      description: "Total disk blocks read"
-    };
-    info.blocks_hit = {
-      value: String(blocksHit),
-      unit: "blocks",
-      description: "Total buffer cache hits"
-    };
-    info.tuples_returned = {
-      value: String(stats.tuples_returned || 0),
-      unit: "rows",
-      description: "Total rows returned by queries"
-    };
-    info.tuples_fetched = {
-      value: String(stats.tuples_fetched || 0),
-      unit: "rows",
-      description: "Total rows fetched by queries"
-    };
-    info.tuples_inserted = {
-      value: String(stats.tuples_inserted || 0),
-      unit: "rows",
-      description: "Total rows inserted"
-    };
-    info.tuples_updated = {
-      value: String(stats.tuples_updated || 0),
-      unit: "rows",
-      description: "Total rows updated"
-    };
-    info.tuples_deleted = {
-      value: String(stats.tuples_deleted || 0),
-      unit: "rows",
-      description: "Total rows deleted"
-    };
-    info.total_deadlocks = {
-      value: String(stats.total_deadlocks || 0),
-      unit: "deadlocks",
-      description: "Total deadlocks detected"
-    };
-    info.temp_files_created = {
-      value: String(stats.temp_files_created || 0),
-      unit: "files",
-      description: "Total temporary files created"
-    };
-    const tempBytes = parseInt(stats.temp_bytes_written || "0", 10);
-    info.temp_bytes_written = {
-      value: formatBytes(tempBytes),
-      unit: "bytes",
-      description: "Total temporary file bytes written"
-    };
-  }
-  const connStatesSql = getMetricSql(METRIC_NAMES.connectionStates);
-  const connResult = await client.query(connStatesSql);
-  for (const row of connResult.rows) {
-    const stateKey = `connections_${row.state.replace(/\s+/g, "_")}`;
-    info[stateKey] = {
-      value: String(row.count),
-      unit: "connections",
-      description: `Connections in '${row.state}' state`
-    };
-  }
-  const uptimeSql = getMetricSql(METRIC_NAMES.uptimeInfo);
-  const uptimeResult = await client.query(uptimeSql);
-  if (uptimeResult.rows.length > 0) {
-    const uptime = uptimeResult.rows[0];
-    info.start_time = {
-      value: uptime.start_time.toISOString(),
-      unit: "timestamp",
-      description: "PostgreSQL server start time"
-    };
-    info.uptime = {
-      value: uptime.uptime,
-      unit: "interval",
-      description: "Server uptime"
-    };
-  }
-  return info;
-}
-async function getInvalidIndexes(client) {
-  const sql = getMetricSql(METRIC_NAMES.H001);
-  const result = await client.query(sql);
-  return result.rows.map((row) => {
-    const transformed = transformMetricRow(row);
-    const indexSizeBytes = parseInt(String(transformed.index_size_bytes || 0), 10);
-    return {
-      schema_name: String(transformed.schema_name || ""),
-      table_name: String(transformed.table_name || ""),
-      index_name: String(transformed.index_name || ""),
-      relation_name: String(transformed.relation_name || ""),
-      index_size_bytes: indexSizeBytes,
-      index_size_pretty: formatBytes(indexSizeBytes),
-      supports_fk: transformed.supports_fk === true || transformed.supports_fk === 1
-    };
-  });
-}
-async function getUnusedIndexes(client) {
-  const sql = getMetricSql(METRIC_NAMES.H002);
-  const result = await client.query(sql);
-  return result.rows.map((row) => {
-    const transformed = transformMetricRow(row);
-    const indexSizeBytes = parseInt(String(transformed.index_size_bytes || 0), 10);
-    return {
-      schema_name: String(transformed.schema_name || ""),
-      table_name: String(transformed.table_name || ""),
-      index_name: String(transformed.index_name || ""),
-      index_definition: String(transformed.index_definition || ""),
-      reason: String(transformed.reason || ""),
-      idx_scan: parseInt(String(transformed.idx_scan || 0), 10),
-      index_size_bytes: indexSizeBytes,
-      idx_is_btree: transformed.idx_is_btree === true || transformed.idx_is_btree === "t",
-      supports_fk: transformed.supports_fk === true || transformed.supports_fk === 1,
-      index_size_pretty: formatBytes(indexSizeBytes)
-    };
-  });
-}
-async function getStatsReset(client) {
-  const sql = getMetricSql(METRIC_NAMES.statsReset);
-  const result = await client.query(sql);
-  const row = result.rows[0] || {};
-  return {
-    stats_reset_epoch: row.stats_reset_epoch ? parseFloat(row.stats_reset_epoch) : null,
-    stats_reset_time: row.stats_reset_time || null,
-    days_since_reset: row.days_since_reset ? parseInt(row.days_since_reset, 10) : null,
-    postmaster_startup_epoch: row.postmaster_startup_epoch ? parseFloat(row.postmaster_startup_epoch) : null,
-    postmaster_startup_time: row.postmaster_startup_time || null
-  };
-}
-async function getCurrentDatabaseInfo(client) {
-  const sql = getMetricSql(METRIC_NAMES.currentDatabase);
-  const result = await client.query(sql);
-  const row = result.rows[0] || {};
-  return {
-    datname: row.datname || "postgres",
-    size_bytes: parseInt(row.size_bytes, 10) || 0
-  };
-}
-async function getRedundantIndexes(client) {
-  const sql = getMetricSql(METRIC_NAMES.H004);
-  const result = await client.query(sql);
-  return result.rows.map((row) => {
-    const transformed = transformMetricRow(row);
-    const indexSizeBytes = parseInt(String(transformed.index_size_bytes || 0), 10);
-    const tableSizeBytes = parseInt(String(transformed.table_size_bytes || 0), 10);
-    let coveringIndexes = [];
-    try {
-      const jsonStr = String(transformed.covering_indexes_json || "[]");
-      const parsed = JSON.parse(jsonStr);
-      if (Array.isArray(parsed)) {
-        coveringIndexes = parsed.map((item) => ({
-          index_name: String(item.index_name || ""),
-          index_definition: String(item.index_definition || "")
-        }));
-      }
-    } catch {}
-    return {
-      schema_name: String(transformed.schema_name || ""),
-      table_name: String(transformed.table_name || ""),
-      index_name: String(transformed.index_name || ""),
-      relation_name: String(transformed.relation_name || ""),
-      access_method: String(transformed.access_method || ""),
-      reason: String(transformed.reason || ""),
-      index_size_bytes: indexSizeBytes,
-      table_size_bytes: tableSizeBytes,
-      index_usage: parseInt(String(transformed.index_usage || 0), 10),
-      supports_fk: transformed.supports_fk === true || transformed.supports_fk === 1,
-      index_definition: String(transformed.index_definition || ""),
-      index_size_pretty: formatBytes(indexSizeBytes),
-      table_size_pretty: formatBytes(tableSizeBytes),
-      covering_indexes: coveringIndexes
-    };
-  });
-}
-function createBaseReport(checkId, checkTitle, nodeName) {
-  const buildTs = resolveBuildTs();
-  return {
-    version: version || null,
-    build_ts: buildTs,
-    checkId,
-    checkTitle,
-    timestamptz: new Date().toISOString(),
-    nodes: {
-      primary: nodeName,
-      standbys: []
-    },
-    results: {}
-  };
-}
-function readTextFileSafe(p) {
-  try {
-    const value = fs4.readFileSync(p, "utf8").trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-}
-function resolveBuildTs() {
-  const envPath = process.env.PGAI_BUILD_TS_FILE;
-  const p = envPath && envPath.trim() ? envPath.trim() : "/BUILD_TS";
-  const fromFile = readTextFileSafe(p);
-  if (fromFile)
-    return fromFile;
-  try {
-    const pkgRoot = path4.resolve(__dirname, "..");
-    const fromPkgFile = readTextFileSafe(path4.join(pkgRoot, "BUILD_TS"));
-    if (fromPkgFile)
-      return fromPkgFile;
-  } catch {}
-  try {
-    const pkgJsonPath = path4.resolve(__dirname, "..", "package.json");
-    const st = fs4.statSync(pkgJsonPath);
-    return st.mtime.toISOString();
-  } catch {
-    return new Date().toISOString();
-  }
-}
-async function generateA002(client, nodeName = "node-01") {
-  const report = createBaseReport("A002", "Postgres major version", nodeName);
-  const postgresVersion = await getPostgresVersion(client);
-  report.results[nodeName] = {
-    data: {
-      version: postgresVersion
-    }
-  };
-  return report;
-}
-async function generateA003(client, nodeName = "node-01") {
-  const report = createBaseReport("A003", "Postgres settings", nodeName);
-  const settings = await getSettings(client);
-  const postgresVersion = await getPostgresVersion(client);
-  report.results[nodeName] = {
-    data: settings,
-    postgres_version: postgresVersion
-  };
-  return report;
-}
-async function generateA004(client, nodeName = "node-01") {
-  const report = createBaseReport("A004", "Cluster information", nodeName);
-  const generalInfo = await getClusterInfo(client);
-  const databaseSizes = await getDatabaseSizes(client);
-  const postgresVersion = await getPostgresVersion(client);
-  report.results[nodeName] = {
-    data: {
-      general_info: generalInfo,
-      database_sizes: databaseSizes
-    },
-    postgres_version: postgresVersion
-  };
-  return report;
-}
-async function generateA007(client, nodeName = "node-01") {
-  const report = createBaseReport("A007", "Altered settings", nodeName);
-  const alteredSettings = await getAlteredSettings(client);
-  const postgresVersion = await getPostgresVersion(client);
-  report.results[nodeName] = {
-    data: alteredSettings,
-    postgres_version: postgresVersion
-  };
-  return report;
-}
-async function generateA013(client, nodeName = "node-01") {
-  const report = createBaseReport("A013", "Postgres minor version", nodeName);
-  const postgresVersion = await getPostgresVersion(client);
-  report.results[nodeName] = {
-    data: {
-      version: postgresVersion
-    }
-  };
-  return report;
-}
-async function generateH001(client, nodeName = "node-01") {
-  const report = createBaseReport("H001", "Invalid indexes", nodeName);
-  const invalidIndexes = await getInvalidIndexes(client);
-  const postgresVersion = await getPostgresVersion(client);
-  const { datname: dbName, size_bytes: dbSizeBytes } = await getCurrentDatabaseInfo(client);
-  const totalCount = invalidIndexes.length;
-  const totalSizeBytes = invalidIndexes.reduce((sum, idx) => sum + idx.index_size_bytes, 0);
-  report.results[nodeName] = {
-    data: {
-      [dbName]: {
-        invalid_indexes: invalidIndexes,
-        total_count: totalCount,
-        total_size_bytes: totalSizeBytes,
-        total_size_pretty: formatBytes(totalSizeBytes),
-        database_size_bytes: dbSizeBytes,
-        database_size_pretty: formatBytes(dbSizeBytes)
-      }
-    },
-    postgres_version: postgresVersion
-  };
-  return report;
-}
-async function generateH002(client, nodeName = "node-01") {
-  const report = createBaseReport("H002", "Unused indexes", nodeName);
-  const unusedIndexes = await getUnusedIndexes(client);
-  const postgresVersion = await getPostgresVersion(client);
-  const statsReset = await getStatsReset(client);
-  const { datname: dbName, size_bytes: dbSizeBytes } = await getCurrentDatabaseInfo(client);
-  const totalCount = unusedIndexes.length;
-  const totalSizeBytes = unusedIndexes.reduce((sum, idx) => sum + idx.index_size_bytes, 0);
-  report.results[nodeName] = {
-    data: {
-      [dbName]: {
-        unused_indexes: unusedIndexes,
-        total_count: totalCount,
-        total_size_bytes: totalSizeBytes,
-        total_size_pretty: formatBytes(totalSizeBytes),
-        database_size_bytes: dbSizeBytes,
-        database_size_pretty: formatBytes(dbSizeBytes),
-        stats_reset: statsReset
-      }
-    },
-    postgres_version: postgresVersion
-  };
-  return report;
-}
-async function generateH004(client, nodeName = "node-01") {
-  const report = createBaseReport("H004", "Redundant indexes", nodeName);
-  const redundantIndexes = await getRedundantIndexes(client);
-  const postgresVersion = await getPostgresVersion(client);
-  const { datname: dbName, size_bytes: dbSizeBytes } = await getCurrentDatabaseInfo(client);
-  const totalCount = redundantIndexes.length;
-  const totalSizeBytes = redundantIndexes.reduce((sum, idx) => sum + idx.index_size_bytes, 0);
-  report.results[nodeName] = {
-    data: {
-      [dbName]: {
-        redundant_indexes: redundantIndexes,
-        total_count: totalCount,
-        total_size_bytes: totalSizeBytes,
-        total_size_pretty: formatBytes(totalSizeBytes),
-        database_size_bytes: dbSizeBytes,
-        database_size_pretty: formatBytes(dbSizeBytes)
-      }
-    },
-    postgres_version: postgresVersion
-  };
-  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
-};
-var CHECK_INFO = {
-  A002: "Postgres major version",
-  A003: "Postgres settings",
-  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"
-};
-async function generateAllReports(client, nodeName = "node-01", onProgress) {
-  const reports = {};
-  const entries = Object.entries(REPORT_GENERATORS);
-  const total = entries.length;
-  let index = 0;
-  for (const [checkId, generator] of entries) {
-    index += 1;
-    onProgress?.({
-      checkId,
-      checkTitle: CHECK_INFO[checkId] || checkId,
-      index,
-      total
-    });
-    reports[checkId] = await generator(client, nodeName);
-  }
-  return reports;
-}
-
-// lib/checkup-api.ts
-import * as https from "https";
-import { URL as URL3 } from "url";
-class RpcError extends Error {
-  rpcName;
-  statusCode;
-  payloadText;
-  payloadJson;
-  constructor(params) {
-    const { rpcName, statusCode, payloadText, payloadJson } = params;
-    super(`RPC ${rpcName} failed: HTTP ${statusCode}`);
-    this.name = "RpcError";
-    this.rpcName = rpcName;
-    this.statusCode = statusCode;
-    this.payloadText = payloadText;
-    this.payloadJson = payloadJson;
-  }
-}
-function formatRpcErrorForDisplay(err) {
-  const lines = [];
-  lines.push(`Error: RPC ${err.rpcName} failed: HTTP ${err.statusCode}`);
-  const obj = err.payloadJson && typeof err.payloadJson === "object" ? err.payloadJson : null;
-  const details = obj && typeof obj.details === "string" ? obj.details : "";
-  const hint = obj && typeof obj.hint === "string" ? obj.hint : "";
-  const message = obj && typeof obj.message === "string" ? obj.message : "";
-  if (message)
-    lines.push(`Message: ${message}`);
-  if (details)
-    lines.push(`Details: ${details}`);
-  if (hint)
-    lines.push(`Hint: ${hint}`);
-  if (!message && !details && !hint) {
-    const t = (err.payloadText || "").trim();
-    if (t)
-      lines.push(t);
-  }
-  return lines;
-}
-function unwrapRpcResponse(parsed) {
-  if (Array.isArray(parsed)) {
-    if (parsed.length === 1)
-      return unwrapRpcResponse(parsed[0]);
-    return parsed;
-  }
-  if (parsed && typeof parsed === "object") {
-    const obj = parsed;
-    if (obj.result !== undefined)
-      return obj.result;
-  }
-  return parsed;
-}
-async function postRpc(params) {
-  const { apiKey, apiBaseUrl, rpcName, bodyObj } = params;
-  if (!apiKey)
-    throw new Error("API key is required");
-  const base = normalizeBaseUrl(apiBaseUrl);
-  const url = new URL3(`${base}/rpc/${rpcName}`);
-  const body = JSON.stringify(bodyObj);
-  const headers = {
-    "access-token": apiKey,
-    Prefer: "return=representation",
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(body).toString()
-  };
-  return new Promise((resolve5, reject) => {
-    const req = https.request(url, {
-      method: "POST",
-      headers
-    }, (res) => {
-      let data = "";
-      res.on("data", (chunk) => data += chunk);
-      res.on("end", () => {
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-          try {
-            const parsed = JSON.parse(data);
-            resolve5(unwrapRpcResponse(parsed));
-          } catch {
-            reject(new Error(`Failed to parse RPC response: ${data}`));
-          }
-        } else {
-          const statusCode = res.statusCode || 0;
-          let payloadJson = null;
-          if (data) {
-            try {
-              payloadJson = JSON.parse(data);
-            } catch {
-              payloadJson = null;
-            }
-          }
-          reject(new RpcError({ rpcName, statusCode, payloadText: data, payloadJson }));
-        }
-      });
-    });
-    req.on("error", (err) => reject(err));
-    req.write(body);
-    req.end();
-  });
-}
-async function createCheckupReport(params) {
-  const { apiKey, apiBaseUrl, project, status } = params;
-  const bodyObj = {
-    access_token: apiKey,
-    project
-  };
-  if (status)
-    bodyObj.status = status;
-  const resp = await postRpc({
-    apiKey,
-    apiBaseUrl,
-    rpcName: "checkup_report_create",
-    bodyObj
-  });
-  const reportId = Number(resp?.report_id);
-  if (!Number.isFinite(reportId) || reportId <= 0) {
-    throw new Error(`Unexpected checkup_report_create response: ${JSON.stringify(resp)}`);
-  }
-  return { reportId };
-}
-async function uploadCheckupReportJson(params) {
-  const { apiKey, apiBaseUrl, reportId, filename, checkId, jsonText } = params;
-  const bodyObj = {
-    access_token: apiKey,
-    checkup_report_id: reportId,
-    filename,
-    check_id: checkId,
-    data: jsonText,
-    type: "json",
-    generate_issue: true
-  };
-  const resp = await postRpc({
-    apiKey,
-    apiBaseUrl,
-    rpcName: "checkup_report_file_post",
-    bodyObj
-  });
-  const chunkId = Number(resp?.report_chunck_id ?? resp?.report_chunk_id);
-  if (!Number.isFinite(chunkId) || chunkId <= 0) {
-    throw new Error(`Unexpected checkup_report_file_post response: ${JSON.stringify(resp)}`);
-  }
-  return { reportChunkId: chunkId };
-}
-
-// bin/postgres-ai.ts
 var rl = null;
 function getReadline() {
   if (!rl) {
@@ -25513,27 +24227,27 @@ function closeReadline() {
   }
 }
 async function execPromise(command) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     childProcess.exec(command, (error2, stdout, stderr) => {
       if (error2) {
         const err = error2;
         err.code = error2.code ?? 1;
         reject(err);
       } else {
-        resolve6({ stdout, stderr });
+        resolve5({ stdout, stderr });
       }
     });
   });
 }
 async function execFilePromise(file, args) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     childProcess.execFile(file, args, (error2, stdout, stderr) => {
       if (error2) {
         const err = error2;
         err.code = error2.code ?? 1;
         reject(err);
       } else {
-        resolve6({ stdout, stderr });
+        resolve5({ stdout, stderr });
       }
     });
   });
@@ -25574,69 +24288,17 @@ function spawn2(cmd, args, options) {
   };
 }
 async function question(prompt) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     getReadline().question(prompt, (answer) => {
-      resolve6(answer);
+      resolve5(answer);
     });
   });
 }
-function expandHomePath(p) {
-  const s = (p || "").trim();
-  if (!s)
-    return s;
-  if (s === "~")
-    return os3.homedir();
-  if (s.startsWith("~/") || s.startsWith("~\\")) {
-    return path5.join(os3.homedir(), s.slice(2));
-  }
-  return s;
-}
-function createTtySpinner(enabled, initialText) {
-  if (!enabled) {
-    return {
-      update: () => {},
-      stop: () => {}
-    };
-  }
-  const frames = ["|", "/", "-", "\\"];
-  const startTs = Date.now();
-  let text = initialText;
-  let frameIdx = 0;
-  let stopped = false;
-  const render = () => {
-    if (stopped)
-      return;
-    const elapsedSec = ((Date.now() - startTs) / 1000).toFixed(1);
-    const frame = frames[frameIdx % frames.length];
-    frameIdx += 1;
-    process.stdout.write(`\r\x1B[2K${frame} ${text} (${elapsedSec}s)`);
-  };
-  const timer = setInterval(render, 120);
-  render();
-  return {
-    update: (t) => {
-      text = t;
-      render();
-    },
-    stop: (finalText) => {
-      if (stopped)
-        return;
-      stopped = true;
-      clearInterval(timer);
-      process.stdout.write("\r\x1B[2K");
-      if (finalText && finalText.trim()) {
-        process.stdout.write(finalText);
-      }
-      process.stdout.write(`
-`);
-    }
-  };
-}
 function getDefaultMonitoringProjectDir() {
   const override = process.env.PGAI_PROJECT_DIR;
   if (override && override.trim())
     return override.trim();
-  return path5.join(getConfigDir(), "monitoring");
+  return path4.join(getConfigDir(), "monitoring");
 }
 async function downloadText(url) {
   const controller = new AbortController;
@@ -25653,12 +24315,12 @@ async function downloadText(url) {
 }
 async function ensureDefaultMonitoringProject() {
   const projectDir = getDefaultMonitoringProjectDir();
-  const composeFile = path5.resolve(projectDir, "docker-compose.yml");
-  const instancesFile = path5.resolve(projectDir, "instances.yml");
-  if (!fs5.existsSync(projectDir)) {
-    fs5.mkdirSync(projectDir, { recursive: true, mode: 448 });
+  const composeFile = path4.resolve(projectDir, "docker-compose.yml");
+  const instancesFile = path4.resolve(projectDir, "instances.yml");
+  if (!fs4.existsSync(projectDir)) {
+    fs4.mkdirSync(projectDir, { recursive: true, mode: 448 });
   }
-  if (!fs5.existsSync(composeFile)) {
+  if (!fs4.existsSync(composeFile)) {
     const refs = [
       process.env.PGAI_PROJECT_REF,
       package_default.version,
@@ -25670,36 +24332,36 @@ async function ensureDefaultMonitoringProject() {
       const url = `https://gitlab.com/postgres-ai/postgres_ai/-/raw/${encodeURIComponent(ref)}/docker-compose.yml`;
       try {
         const text = await downloadText(url);
-        fs5.writeFileSync(composeFile, text, { encoding: "utf8", mode: 384 });
+        fs4.writeFileSync(composeFile, text, { encoding: "utf8", mode: 384 });
         break;
       } catch (err) {
         lastErr = err;
       }
     }
-    if (!fs5.existsSync(composeFile)) {
+    if (!fs4.existsSync(composeFile)) {
       const msg = lastErr instanceof Error ? lastErr.message : String(lastErr);
       throw new Error(`Failed to bootstrap docker-compose.yml: ${msg}`);
     }
   }
-  if (!fs5.existsSync(instancesFile)) {
+  if (!fs4.existsSync(instancesFile)) {
     const header = `# PostgreSQL instances to monitor
 ` + `# Add your instances using: pgai mon targets add <connection-string> <name>
 
 `;
-    fs5.writeFileSync(instancesFile, header, { encoding: "utf8", mode: 384 });
+    fs4.writeFileSync(instancesFile, header, { encoding: "utf8", mode: 384 });
   }
-  const pgwatchConfig = path5.resolve(projectDir, ".pgwatch-config");
-  if (!fs5.existsSync(pgwatchConfig)) {
-    fs5.writeFileSync(pgwatchConfig, "", { encoding: "utf8", mode: 384 });
+  const pgwatchConfig = path4.resolve(projectDir, ".pgwatch-config");
+  if (!fs4.existsSync(pgwatchConfig)) {
+    fs4.writeFileSync(pgwatchConfig, "", { encoding: "utf8", mode: 384 });
   }
-  const envFile = path5.resolve(projectDir, ".env");
-  if (!fs5.existsSync(envFile)) {
+  const envFile = path4.resolve(projectDir, ".env");
+  if (!fs4.existsSync(envFile)) {
     const envText = `PGAI_TAG=${package_default.version}
 # PGAI_REGISTRY=registry.gitlab.com/postgres-ai/postgres_ai
 `;
-    fs5.writeFileSync(envFile, envText, { encoding: "utf8", mode: 384 });
+    fs4.writeFileSync(envFile, envText, { encoding: "utf8", mode: 384 });
   }
-  return { fs: fs5, path: path5, projectDir, composeFile, instancesFile };
+  return { fs: fs4, path: path4, projectDir, composeFile, instancesFile };
 }
 function getConfig(opts) {
   let apiKey = opts.apiKey || process.env.PGAI_API_KEY || "";
@@ -25731,16 +24393,6 @@ function printResult(result, json2) {
 }
 var program2 = new Command;
 program2.name("postgres-ai").description("PostgresAI CLI").version(package_default.version).option("--api-key <key>", "API key (overrides PGAI_API_KEY)").option("--api-base-url <url>", "API base URL for backend RPC (overrides PGAI_API_BASE_URL)").option("--ui-base-url <url>", "UI base URL for browser routes (overrides PGAI_UI_BASE_URL)");
-program2.command("set-default-project <project>").description("store default project for checkup uploads").action(async (project) => {
-  const value = (project || "").trim();
-  if (!value) {
-    console.error("Error: project is required");
-    process.exitCode = 1;
-    return;
-  }
-  writeConfig({ defaultProject: value });
-  console.log(`Default project saved: ${value}`);
-});
 program2.command("prepare-db [conn]").description("prepare database for monitoring: create monitoring user, required view(s), and grant permissions (idempotent)").option("--db-url <url>", "PostgreSQL connection URL (admin) to run the setup against (deprecated; pass it as positional arg)").option("-h, --host <host>", "PostgreSQL host (psql-like)").option("-p, --port <port>", "PostgreSQL port (psql-like)").option("-U, --username <username>", "PostgreSQL user (psql-like)").option("-d, --dbname <dbname>", "PostgreSQL database name (psql-like)").option("--admin-password <password>", "Admin connection password (otherwise uses PGPASSWORD if set)").option("--monitoring-user <name>", "Monitoring role name to create/update", DEFAULT_MONITORING_USER).option("--password <password>", "Monitoring role password (overrides PGAI_MON_PASSWORD)").option("--skip-optional-permissions", "Skip optional permissions (RDS/self-managed extras)", false).option("--verify", "Verify that monitoring role/permissions are in place (no changes)", false).option("--reset-password", "Reset monitoring role password only (no other changes)", false).option("--print-sql", "Print SQL plan and exit (no changes applied)", false).option("--print-password", "Print generated monitoring password (DANGEROUS in CI logs)", false).addHelpText("after", [
   "",
   "Examples:",
@@ -26011,206 +24663,16 @@ program2.command("prepare-db [conn]").description("prepare database for monitori
     }
   }
 });
-program2.command("checkup [conn]").description("generate health check reports directly from PostgreSQL (express mode)").option("--check-id <id>", `specific check to run: ${Object.keys(CHECK_INFO).join(", ")}, or ALL`, "ALL").option("--node-name <name>", "node name for reports", "node-01").option("--output <path>", "output directory for JSON files").option("--[no-]upload", "upload JSON results to PostgresAI (default: enabled; requires API key)", undefined).option("--project <project>", "project name or ID for remote upload (used with --upload; defaults to config defaultProject; auto-generated on first run)").option("--json", "output JSON to stdout (implies --no-upload)").addHelpText("after", [
-  "",
-  "Available checks:",
-  ...Object.entries(CHECK_INFO).map(([id, title]) => `  ${id}: ${title}`),
-  "",
-  "Examples:",
-  "  postgresai checkup postgresql://user:pass@host:5432/db",
-  "  postgresai checkup postgresql://user:pass@host:5432/db --check-id A003",
-  "  postgresai checkup postgresql://user:pass@host:5432/db --output ./reports",
-  "  postgresai checkup postgresql://user:pass@host:5432/db --project my_project",
-  "  postgresai set-default-project my_project",
-  "  postgresai checkup postgresql://user:pass@host:5432/db",
-  "  postgresai checkup postgresql://user:pass@host:5432/db --no-upload --json"
-].join(`
-`)).action(async (conn, opts, cmd) => {
-  if (!conn) {
-    cmd.outputHelp();
-    process.exitCode = 1;
-    return;
-  }
-  const shouldPrintJson = !!opts.json;
-  const shouldUpload = opts.upload !== false && !shouldPrintJson;
-  const generateDefaultProjectName = () => {
-    return `project_${crypto2.randomBytes(6).toString("hex")}`;
-  };
-  let outputPath;
-  if (opts.output) {
-    const outputDir = expandHomePath(opts.output);
-    outputPath = path5.isAbsolute(outputDir) ? outputDir : path5.resolve(process.cwd(), outputDir);
-    if (!fs5.existsSync(outputPath)) {
-      try {
-        fs5.mkdirSync(outputPath, { recursive: true });
-      } catch (e) {
-        const errAny = e;
-        const code = typeof errAny?.code === "string" ? errAny.code : "";
-        const msg = errAny instanceof Error ? errAny.message : String(errAny);
-        if (code === "EACCES" || code === "EPERM" || code === "ENOENT") {
-          console.error(`Error: Failed to create output directory: ${outputPath}`);
-          console.error(`Reason: ${msg}`);
-          console.error("Tip: choose a writable path, e.g. --output ./reports or --output ~/reports");
-          process.exitCode = 1;
-          return;
-        }
-        throw e;
-      }
-    }
-  }
-  let uploadCfg;
-  let projectWasGenerated = false;
-  if (shouldUpload) {
-    const rootOpts = program2.opts();
-    const { apiKey } = getConfig(rootOpts);
-    if (!apiKey) {
-      console.error("Error: API key is required for upload");
-      console.error("Tip: run 'postgresai auth' or pass --api-key / set PGAI_API_KEY");
-      process.exitCode = 1;
-      return;
-    }
-    const cfg = readConfig();
-    const { apiBaseUrl } = resolveBaseUrls2(rootOpts, cfg);
-    let project = (opts.project || cfg.defaultProject || "").trim();
-    if (!project) {
-      project = generateDefaultProjectName();
-      projectWasGenerated = true;
-      try {
-        writeConfig({ defaultProject: project });
-      } catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        console.error(`Warning: Failed to save generated default project: ${message}`);
-      }
-    }
-    uploadCfg = {
-      apiKey,
-      apiBaseUrl,
-      project
-    };
-  }
-  const adminConn = resolveAdminConnection({
-    conn,
-    envPassword: process.env.PGPASSWORD
-  });
-  let client;
-  const spinnerEnabled = !!process.stdout.isTTY && !!shouldUpload;
-  const spinner = createTtySpinner(spinnerEnabled, "Connecting to Postgres");
-  try {
-    spinner.update("Connecting to Postgres");
-    const connResult = await connectWithSslFallback(Client, adminConn);
-    client = connResult.client;
-    let reports;
-    let uploadSummary;
-    if (opts.checkId === "ALL") {
-      reports = await generateAllReports(client, opts.nodeName, (p) => {
-        spinner.update(`Running ${p.checkId}: ${p.checkTitle} (${p.index}/${p.total})`);
-      });
-    } else {
-      const checkId = opts.checkId.toUpperCase();
-      const generator = REPORT_GENERATORS[checkId];
-      if (!generator) {
-        spinner.stop();
-        console.error(`Unknown check ID: ${opts.checkId}`);
-        console.error(`Available: ${Object.keys(CHECK_INFO).join(", ")}, ALL`);
-        process.exitCode = 1;
-        return;
-      }
-      spinner.update(`Running ${checkId}: ${CHECK_INFO[checkId] || checkId}`);
-      reports = { [checkId]: await generator(client, opts.nodeName) };
-    }
-    if (uploadCfg) {
-      spinner.update("Creating remote checkup report");
-      const created = await createCheckupReport({
-        apiKey: uploadCfg.apiKey,
-        apiBaseUrl: uploadCfg.apiBaseUrl,
-        project: uploadCfg.project
-      });
-      const reportId = created.reportId;
-      const logUpload = (msg) => {
-        if (shouldPrintJson) {
-          console.error(msg);
-        } else {
-          console.log(msg);
-        }
-      };
-      logUpload(`Created remote checkup report: ${reportId}`);
-      const uploaded = [];
-      for (const [checkId, report] of Object.entries(reports)) {
-        spinner.update(`Uploading ${checkId}.json`);
-        const jsonText = JSON.stringify(report, null, 2);
-        const r = await uploadCheckupReportJson({
-          apiKey: uploadCfg.apiKey,
-          apiBaseUrl: uploadCfg.apiBaseUrl,
-          reportId,
-          filename: `${checkId}.json`,
-          checkId,
-          jsonText
-        });
-        uploaded.push({ checkId, filename: `${checkId}.json`, chunkId: r.reportChunkId });
-      }
-      logUpload("Upload completed");
-      uploadSummary = { project: uploadCfg.project, reportId, uploaded };
-    }
-    spinner.stop();
-    if (opts.output) {
-      const outDir = outputPath || path5.resolve(process.cwd(), expandHomePath(opts.output));
-      for (const [checkId, report] of Object.entries(reports)) {
-        const filePath = path5.join(outDir, `${checkId}.json`);
-        fs5.writeFileSync(filePath, JSON.stringify(report, null, 2), "utf8");
-        console.log(`\u2713 ${checkId}: ${filePath}`);
-      }
-    }
-    if (uploadSummary) {
-      const out = shouldPrintJson ? console.error : console.log;
-      out(`
-Checkup report uploaded`);
-      out(`======================
-`);
-      if (projectWasGenerated) {
-        out(`Project: ${uploadSummary.project} (generated and saved as default)`);
-      } else {
-        out(`Project: ${uploadSummary.project}`);
-      }
-      out(`Report ID: ${uploadSummary.reportId}`);
-      out("View in Console: console.postgres.ai \u2192 Support \u2192 checkup reports");
-      out("");
-      out("Files:");
-      for (const item of uploadSummary.uploaded) {
-        out(`- ${item.checkId}: ${item.filename}`);
-      }
-    }
-    if (shouldPrintJson) {
-      console.log(JSON.stringify(reports, null, 2));
-    } else if (!shouldUpload && !opts.output) {
-      console.log(JSON.stringify(reports, null, 2));
-    }
-  } catch (error2) {
-    spinner.stop();
-    if (error2 instanceof RpcError) {
-      for (const line of formatRpcErrorForDisplay(error2)) {
-        console.error(line);
-      }
-    } else {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      console.error(`Error: ${message}`);
-    }
-    process.exitCode = 1;
-  } finally {
-    if (client) {
-      await client.end();
-    }
-  }
-});
 function resolvePaths() {
   const startDir = process.cwd();
   let currentDir = startDir;
   while (true) {
-    const composeFile = path5.resolve(currentDir, "docker-compose.yml");
-    if (fs5.existsSync(composeFile)) {
-      const instancesFile = path5.resolve(currentDir, "instances.yml");
-      return { fs: fs5, path: path5, projectDir: currentDir, composeFile, instancesFile };
+    const composeFile = path4.resolve(currentDir, "docker-compose.yml");
+    if (fs4.existsSync(composeFile)) {
+      const instancesFile = path4.resolve(currentDir, "instances.yml");
+      return { fs: fs4, path: path4, projectDir: currentDir, composeFile, instancesFile };
     }
-    const parentDir = path5.dirname(currentDir);
+    const parentDir = path4.dirname(currentDir);
     if (parentDir === currentDir)
       break;
     currentDir = parentDir;
@@ -26276,12 +24738,12 @@ async function runCompose(args) {
     return 1;
   }
   const env = { ...process.env };
-  const cfgPath = path5.resolve(projectDir, ".pgwatch-config");
-  if (fs5.existsSync(cfgPath)) {
+  const cfgPath = path4.resolve(projectDir, ".pgwatch-config");
+  if (fs4.existsSync(cfgPath)) {
     try {
-      const stats = fs5.statSync(cfgPath);
+      const stats = fs4.statSync(cfgPath);
       if (!stats.isDirectory()) {
-        const content = fs5.readFileSync(cfgPath, "utf8");
+        const content = fs4.readFileSync(cfgPath, "utf8");
         const match = content.match(/^grafana_password=([^\r\n]+)/m);
         if (match) {
           env.GF_SECURITY_ADMIN_PASSWORD = match[1].trim();
@@ -26289,13 +24751,13 @@ async function runCompose(args) {
       }
     } catch (err) {}
   }
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     const child = spawn2(cmd[0], [...cmd.slice(1), "-f", composeFile, ...args], {
       stdio: "inherit",
       env,
       cwd: projectDir
     });
-    child.on("close", (code) => resolve6(code || 0));
+    child.on("close", (code) => resolve5(code || 0));
   });
 }
 program2.command("help", { isDefault: true }).description("show help").action(() => {
@@ -26313,17 +24775,17 @@ mon.command("local-install").description("install local monitoring stack (genera
   const { projectDir } = await resolveOrInitPaths();
   console.log(`Project directory: ${projectDir}
 `);
-  const envFile = path5.resolve(projectDir, ".env");
+  const envFile = path4.resolve(projectDir, ".env");
   const imageTag = opts.tag || package_default.version;
   const envLines = [`PGAI_TAG=${imageTag}`];
-  if (fs5.existsSync(envFile)) {
-    const existingEnv = fs5.readFileSync(envFile, "utf8");
+  if (fs4.existsSync(envFile)) {
+    const existingEnv = fs4.readFileSync(envFile, "utf8");
     const pwdMatch = existingEnv.match(/^GF_SECURITY_ADMIN_PASSWORD=(.+)$/m);
     if (pwdMatch) {
       envLines.push(`GF_SECURITY_ADMIN_PASSWORD=${pwdMatch[1]}`);
     }
   }
-  fs5.writeFileSync(envFile, envLines.join(`
+  fs4.writeFileSync(envFile, envLines.join(`
 `) + `
 `, { encoding: "utf8", mode: 384 });
   if (opts.tag) {
@@ -26359,7 +24821,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
     if (opts.apiKey) {
       console.log("Using API key provided via --api-key parameter");
       writeConfig({ apiKey: opts.apiKey });
-      fs5.writeFileSync(path5.resolve(projectDir, ".pgwatch-config"), `api_key=${opts.apiKey}
+      fs4.writeFileSync(path4.resolve(projectDir, ".pgwatch-config"), `api_key=${opts.apiKey}
 `, {
         encoding: "utf8",
         mode: 384
@@ -26380,7 +24842,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
           const trimmedKey = inputApiKey.trim();
           if (trimmedKey) {
             writeConfig({ apiKey: trimmedKey });
-            fs5.writeFileSync(path5.resolve(projectDir, ".pgwatch-config"), `api_key=${trimmedKey}
+            fs4.writeFileSync(path4.resolve(projectDir, ".pgwatch-config"), `api_key=${trimmedKey}
 `, {
               encoding: "utf8",
               mode: 384
@@ -26417,7 +24879,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
 # Add your instances using: postgres-ai mon targets add
 
 `;
-    fs5.writeFileSync(instancesPath, emptyInstancesContent, "utf8");
+    fs4.writeFileSync(instancesPath, emptyInstancesContent, "utf8");
     console.log(`Instances file: ${instancesPath}`);
     console.log(`Project directory: ${projectDir2}
 `);
@@ -26449,7 +24911,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
     node_name: ${instanceName}
     sink_type: ~sink_type~
 `;
-      fs5.appendFileSync(instancesPath, body, "utf8");
+      fs4.appendFileSync(instancesPath, body, "utf8");
       console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
       console.log("Testing connection to the added instance...");
@@ -26504,7 +24966,7 @@ You can provide either:`);
     node_name: ${instanceName}
     sink_type: ~sink_type~
 `;
-            fs5.appendFileSync(instancesPath, body, "utf8");
+            fs4.appendFileSync(instancesPath, body, "utf8");
             console.log(`\u2713 Monitoring target '${instanceName}' added
 `);
             console.log("Testing connection to the added instance...");
@@ -26544,13 +25006,13 @@ You can provide either:`);
   console.log(`\u2713 Configuration updated
 `);
   console.log(opts.demo ? "Step 4: Configuring Grafana security..." : "Step 4: Configuring Grafana security...");
-  const cfgPath = path5.resolve(projectDir, ".pgwatch-config");
+  const cfgPath = path4.resolve(projectDir, ".pgwatch-config");
   let grafanaPassword = "";
   try {
-    if (fs5.existsSync(cfgPath)) {
-      const stats = fs5.statSync(cfgPath);
+    if (fs4.existsSync(cfgPath)) {
+      const stats = fs4.statSync(cfgPath);
       if (!stats.isDirectory()) {
-        const content = fs5.readFileSync(cfgPath, "utf8");
+        const content = fs4.readFileSync(cfgPath, "utf8");
         const match = content.match(/^grafana_password=([^\r\n]+)/m);
         if (match) {
           grafanaPassword = match[1].trim();
@@ -26563,15 +25025,15 @@ You can provide either:`);
 '`);
       grafanaPassword = password.trim();
       let configContent = "";
-      if (fs5.existsSync(cfgPath)) {
-        const stats = fs5.statSync(cfgPath);
+      if (fs4.existsSync(cfgPath)) {
+        const stats = fs4.statSync(cfgPath);
         if (!stats.isDirectory()) {
-          configContent = fs5.readFileSync(cfgPath, "utf8");
+          configContent = fs4.readFileSync(cfgPath, "utf8");
         }
       }
       const lines = configContent.split(/\r?\n/).filter((l) => !/^grafana_password=/.test(l));
       lines.push(`grafana_password=${grafanaPassword}`);
-      fs5.writeFileSync(cfgPath, lines.filter(Boolean).join(`
+      fs4.writeFileSync(cfgPath, lines.filter(Boolean).join(`
 `) + `
 `, "utf8");
     }
@@ -26685,7 +25147,7 @@ mon.command("health").description("health check for monitoring services").option
     if (attempt > 1) {
       console.log(`Retrying (attempt ${attempt}/${maxAttempts})...
 `);
-      await new Promise((resolve6) => setTimeout(resolve6, 5000));
+      await new Promise((resolve5) => setTimeout(resolve5, 5000));
     }
     allHealthy = true;
     for (const service of services) {
@@ -26733,11 +25195,11 @@ mon.command("config").description("show monitoring services configuration").acti
   console.log(`Project Directory: ${projectDir}`);
   console.log(`Docker Compose File: ${composeFile}`);
   console.log(`Instances File: ${instancesFile}`);
-  if (fs5.existsSync(instancesFile)) {
+  if (fs4.existsSync(instancesFile)) {
     console.log(`
 Instances configuration:
 `);
-    const text = fs5.readFileSync(instancesFile, "utf8");
+    const text = fs4.readFileSync(instancesFile, "utf8");
     process.stdout.write(text);
     if (!/\n$/.test(text))
       console.log();
@@ -26752,8 +25214,8 @@ mon.command("update").description("update monitoring stack").action(async () =>
   console.log(`Updating PostgresAI monitoring stack...
 `);
   try {
-    const gitDir = path5.resolve(process.cwd(), ".git");
-    if (!fs5.existsSync(gitDir)) {
+    const gitDir = path4.resolve(process.cwd(), ".git");
+    if (!fs4.existsSync(gitDir)) {
       console.error("Not a git repository. Cannot update.");
       process.exitCode = 1;
       return;
@@ -26879,13 +25341,13 @@ mon.command("check").description("monitoring services system readiness check").a
 var targets = mon.command("targets").description("manage databases to monitor");
 targets.command("list").description("list monitoring target databases").action(async () => {
   const { instancesFile: instancesPath, projectDir } = await resolveOrInitPaths();
-  if (!fs5.existsSync(instancesPath)) {
+  if (!fs4.existsSync(instancesPath)) {
     console.error(`instances.yml not found in ${projectDir}`);
     process.exitCode = 1;
     return;
   }
   try {
-    const content = fs5.readFileSync(instancesPath, "utf8");
+    const content = fs4.readFileSync(instancesPath, "utf8");
     const instances = load(content);
     if (!instances || !Array.isArray(instances) || instances.length === 0) {
       console.log("No monitoring targets configured");
@@ -26934,8 +25396,8 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
   const db = m[5];
   const instanceName = name && name.trim() ? name.trim() : `${host}-${db}`.replace(/[^a-zA-Z0-9-]/g, "-");
   try {
-    if (fs5.existsSync(file)) {
-      const content2 = fs5.readFileSync(file, "utf8");
+    if (fs4.existsSync(file)) {
+      const content2 = fs4.readFileSync(file, "utf8");
       const instances = load(content2) || [];
       if (Array.isArray(instances)) {
         const exists = instances.some((inst) => inst.name === instanceName);
@@ -26947,7 +25409,7 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
       }
     }
   } catch (err) {
-    const content2 = fs5.existsSync(file) ? fs5.readFileSync(file, "utf8") : "";
+    const content2 = fs4.existsSync(file) ? fs4.readFileSync(file, "utf8") : "";
     if (new RegExp(`^- name: ${instanceName}$`, "m").test(content2)) {
       console.error(`Monitoring target '${instanceName}' already exists`);
       process.exitCode = 1;
@@ -26966,20 +25428,20 @@ targets.command("add [connStr] [name]").description("add monitoring target datab
     node_name: ${instanceName}
     sink_type: ~sink_type~
 `;
-  const content = fs5.existsSync(file) ? fs5.readFileSync(file, "utf8") : "";
-  fs5.appendFileSync(file, (content && !/\n$/.test(content) ? `
+  const content = fs4.existsSync(file) ? fs4.readFileSync(file, "utf8") : "";
+  fs4.appendFileSync(file, (content && !/\n$/.test(content) ? `
 ` : "") + body, "utf8");
   console.log(`Monitoring target '${instanceName}' added`);
 });
 targets.command("remove <name>").description("remove monitoring target database").action(async (name) => {
   const { instancesFile: file } = await resolveOrInitPaths();
-  if (!fs5.existsSync(file)) {
+  if (!fs4.existsSync(file)) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
   }
   try {
-    const content = fs5.readFileSync(file, "utf8");
+    const content = fs4.readFileSync(file, "utf8");
     const instances = load(content);
     if (!instances || !Array.isArray(instances)) {
       console.error("Invalid instances.yml format");
@@ -26992,7 +25454,7 @@ targets.command("remove <name>").description("remove monitoring target database"
       process.exitCode = 1;
       return;
     }
-    fs5.writeFileSync(file, dump(filtered), "utf8");
+    fs4.writeFileSync(file, dump(filtered), "utf8");
     console.log(`Monitoring target '${name}' removed`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -27002,13 +25464,13 @@ targets.command("remove <name>").description("remove monitoring target database"
 });
 targets.command("test <name>").description("test monitoring target database connectivity").action(async (name) => {
   const { instancesFile: instancesPath } = await resolveOrInitPaths();
-  if (!fs5.existsSync(instancesPath)) {
+  if (!fs4.existsSync(instancesPath)) {
     console.error("instances.yml not found");
     process.exitCode = 1;
     return;
   }
   try {
-    const content = fs5.readFileSync(instancesPath, "utf8");
+    const content = fs4.readFileSync(instancesPath, "utf8");
     const instances = load(content);
     if (!instances || !Array.isArray(instances)) {
       console.error("Invalid instances.yml format");
@@ -27052,7 +25514,6 @@ auth.command("login", { isDefault: true }).description("authenticate via browser
       return;
     }
     writeConfig({ apiKey: trimmedKey });
-    deleteConfigKeys(["orgId", "defaultProject"]);
     console.log(`API key saved to ${getConfigPath()}`);
     return;
   }
@@ -27070,7 +25531,7 @@ auth.command("login", { isDefault: true }).description("authenticate via browser
     console.log("Starting local callback server...");
     const requestedPort = opts.port || 0;
     const callbackServer = createCallbackServer(requestedPort, params.state, 120000);
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
+    await new Promise((resolve5) => setTimeout(resolve5, 100));
     const actualPort = callbackServer.getPort();
     const redirectUri = `http://localhost:${actualPort}/callback`;
     console.log(`Callback server listening on port ${actualPort}`);
@@ -27195,7 +25656,6 @@ Please verify the --api-base-url parameter.`);
           baseUrl: apiBaseUrl,
           orgId
         });
-        deleteConfigKeys(["defaultProject"]);
         console.log(`
 Authentication successful!`);
         console.log(`API key saved to: ${getConfigPath()}`);
@@ -27244,15 +25704,15 @@ To authenticate, run: pgai auth`);
 });
 auth.command("remove-key").description("remove API key").action(async () => {
   const newConfigPath = getConfigPath();
-  const hasNewConfig = fs5.existsSync(newConfigPath);
+  const hasNewConfig = fs4.existsSync(newConfigPath);
   let legacyPath;
   try {
     const { projectDir } = await resolveOrInitPaths();
-    legacyPath = path5.resolve(projectDir, ".pgwatch-config");
+    legacyPath = path4.resolve(projectDir, ".pgwatch-config");
   } catch {
-    legacyPath = path5.resolve(process.cwd(), ".pgwatch-config");
+    legacyPath = path4.resolve(process.cwd(), ".pgwatch-config");
   }
-  const hasLegacyConfig = fs5.existsSync(legacyPath) && fs5.statSync(legacyPath).isFile();
+  const hasLegacyConfig = fs4.existsSync(legacyPath) && fs4.statSync(legacyPath).isFile();
   if (!hasNewConfig && !hasLegacyConfig) {
     console.log("No API key configured");
     return;
@@ -27262,11 +25722,11 @@ auth.command("remove-key").description("remove API key").action(async () => {
   }
   if (hasLegacyConfig) {
     try {
-      const content = fs5.readFileSync(legacyPath, "utf8");
+      const content = fs4.readFileSync(legacyPath, "utf8");
       const filtered = content.split(/\r?\n/).filter((l) => !/^api_key=/.test(l)).join(`
 `).replace(/\n+$/g, `
 `);
-      fs5.writeFileSync(legacyPath, filtered, "utf8");
+      fs4.writeFileSync(legacyPath, filtered, "utf8");
     } catch (err) {
       console.warn(`Warning: Could not update legacy config: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -27277,7 +25737,7 @@ To authenticate again, run: pgai auth`);
 });
 mon.command("generate-grafana-password").description("generate Grafana password for monitoring services").action(async () => {
   const { projectDir } = await resolveOrInitPaths();
-  const cfgPath = path5.resolve(projectDir, ".pgwatch-config");
+  const cfgPath = path4.resolve(projectDir, ".pgwatch-config");
   try {
     const { stdout: password } = await execPromise(`openssl rand -base64 12 | tr -d '
 '`);
@@ -27288,17 +25748,17 @@ mon.command("generate-grafana-password").description("generate Grafana password
       return;
     }
     let configContent = "";
-    if (fs5.existsSync(cfgPath)) {
-      const stats = fs5.statSync(cfgPath);
+    if (fs4.existsSync(cfgPath)) {
+      const stats = fs4.statSync(cfgPath);
       if (stats.isDirectory()) {
         console.error(".pgwatch-config is a directory, expected a file. Skipping read.");
       } else {
-        configContent = fs5.readFileSync(cfgPath, "utf8");
+        configContent = fs4.readFileSync(cfgPath, "utf8");
       }
     }
     const lines = configContent.split(/\r?\n/).filter((l) => !/^grafana_password=/.test(l));
     lines.push(`grafana_password=${newPassword}`);
-    fs5.writeFileSync(cfgPath, lines.filter(Boolean).join(`
+    fs4.writeFileSync(cfgPath, lines.filter(Boolean).join(`
 `) + `
 `, "utf8");
     console.log("\u2713 New Grafana password generated and saved");
@@ -27320,19 +25780,19 @@ Note: This command requires 'openssl' to be installed`);
 });
 mon.command("show-grafana-credentials").description("show Grafana credentials for monitoring services").action(async () => {
   const { projectDir } = await resolveOrInitPaths();
-  const cfgPath = path5.resolve(projectDir, ".pgwatch-config");
-  if (!fs5.existsSync(cfgPath)) {
+  const cfgPath = path4.resolve(projectDir, ".pgwatch-config");
+  if (!fs4.existsSync(cfgPath)) {
     console.error("Configuration file not found. Run 'postgres-ai mon local-install' first.");
     process.exitCode = 1;
     return;
   }
-  const stats = fs5.statSync(cfgPath);
+  const stats = fs4.statSync(cfgPath);
   if (stats.isDirectory()) {
     console.error(".pgwatch-config is a directory, expected a file. Cannot read credentials.");
     process.exitCode = 1;
     return;
   }
-  const content = fs5.readFileSync(cfgPath, "utf8");
+  const content = fs4.readFileSync(cfgPath, "utf8");
   const lines = content.split(/\r?\n/);
   let password = "";
   for (const line of lines) {
@@ -27516,29 +25976,29 @@ mcp.command("install [client]").description("install MCP server configuration fo
     let configDir;
     switch (client) {
       case "cursor":
-        configPath = path5.join(homeDir, ".cursor", "mcp.json");
-        configDir = path5.dirname(configPath);
+        configPath = path4.join(homeDir, ".cursor", "mcp.json");
+        configDir = path4.dirname(configPath);
         break;
       case "windsurf":
-        configPath = path5.join(homeDir, ".windsurf", "mcp.json");
-        configDir = path5.dirname(configPath);
+        configPath = path4.join(homeDir, ".windsurf", "mcp.json");
+        configDir = path4.dirname(configPath);
         break;
       case "codex":
-        configPath = path5.join(homeDir, ".codex", "mcp.json");
-        configDir = path5.dirname(configPath);
+        configPath = path4.join(homeDir, ".codex", "mcp.json");
+        configDir = path4.dirname(configPath);
         break;
       default:
         console.error(`Configuration not implemented for: ${client}`);
         process.exitCode = 1;
         return;
     }
-    if (!fs5.existsSync(configDir)) {
-      fs5.mkdirSync(configDir, { recursive: true });
+    if (!fs4.existsSync(configDir)) {
+      fs4.mkdirSync(configDir, { recursive: true });
     }
     let config2 = { mcpServers: {} };
-    if (fs5.existsSync(configPath)) {
+    if (fs4.existsSync(configPath)) {
       try {
-        const content = fs5.readFileSync(configPath, "utf8");
+        const content = fs4.readFileSync(configPath, "utf8");
         config2 = JSON.parse(content);
         if (!config2.mcpServers) {
           config2.mcpServers = {};
@@ -27551,7 +26011,7 @@ mcp.command("install [client]").description("install MCP server configuration fo
       command: pgaiPath,
       args: ["mcp", "start"]
     };
-    fs5.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf8");
+    fs4.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf8");
     console.log(`\u2713 PostgresAI MCP server configured for ${client}`);
     console.log(`  Config file: ${configPath}`);
     console.log("");