postgresai 0.14.0 → 0.15.0-dev.1

package/dist/bin/postgres-ai.js

@@ -12833,7 +12833,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str2) {
+    return function time3(str2) {
       const matches = TIME.exec(str2);
       if (!matches)
         return false;
@@ -13064,7 +13064,7 @@ var {
 // package.json
 var package_default = {
   name: "postgresai",
-  version: "0.14.0",
+  version: "0.15.0-dev.1",
   description: "postgres_ai CLI",
   license: "Apache-2.0",
   private: false,
@@ -13141,7 +13141,8 @@ function readConfig() {
     apiKey: null,
     baseUrl: null,
     orgId: null,
-    defaultProject: null
+    defaultProject: null,
+    projectName: null
   };
   const userConfigPath = getConfigPath();
   if (fs.existsSync(userConfigPath)) {
@@ -13152,6 +13153,7 @@ function readConfig() {
       config.baseUrl = parsed.baseUrl ?? null;
       config.orgId = parsed.orgId ?? null;
       config.defaultProject = parsed.defaultProject ?? null;
+      config.projectName = parsed.projectName ?? null;
       return config;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -15890,7 +15892,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";
+var version = "0.15.0-dev.1";
 var package_default2 = {
   name: "postgresai",
   version,
@@ -15970,7 +15972,8 @@ function readConfig2() {
     apiKey: null,
     baseUrl: null,
     orgId: null,
-    defaultProject: null
+    defaultProject: null,
+    projectName: null
   };
   const userConfigPath = getConfigPath2();
   if (fs2.existsSync(userConfigPath)) {
@@ -15981,6 +15984,7 @@ function readConfig2() {
       config.baseUrl = parsed.baseUrl ?? null;
       config.orgId = parsed.orgId ?? null;
       config.defaultProject = parsed.defaultProject ?? null;
+      config.projectName = parsed.projectName ?? null;
       return config;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -26525,6 +26529,187 @@ where datname = current_database()
     },
     gauges: ["stats_reset_epoch", "seconds_since_reset"],
     statement_timeout_seconds: 15
+  },
+  pg_table_bloat: {
+    description: "This metric analyzes estimated table bloat by calculating the estimated vs actual table pages and sizes. It provides insights into estimated bloat percentage, real size, extra size due to estimated bloat, and estimated bloat size considering fill factor. This metric helps administrators identify tables that may need maintenance like VACUUM FULL or table reorganization.",
+    sqls: {
+      11: `select current_database() as tag_datname, schemaname as tag_schemaname, tblname as tag_tblname, (bs*tblpages)/(1024*1024)::float as real_size_mib, /* pgwatch_generated */
+  (tblpages-est_tblpages)*bs as extra_size,
+  case when tblpages > 0 and tblpages - est_tblpages > 0
+    then 100 * (tblpages - est_tblpages)/tblpages::float
+    else 0
+  end as extra_pct, fillfactor,
+  case when tblpages - est_tblpages_ff > 0
+    then (tblpages-est_tblpages_ff)*bs
+    else 0
+  end as bloat_size,
+  case when tblpages > 0 and tblpages - est_tblpages_ff > 0
+    then 100 * (tblpages - est_tblpages_ff)/tblpages::float
+    else 0
+  end as bloat_pct, is_na
+  -- , tpl_hdr_size, tpl_data_size, (pst).free_percent + (pst).dead_tuple_percent as real_frag -- (DEBUG INFO)
+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, tblid, schemaname, tblname, heappages, toastpages, is_na
+    -- , tpl_hdr_size, tpl_data_size, pgstattuple(tblid) as pst -- (DEBUG INFO)
+  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, bs - page_hdr as size_per_block, (heappages + toastpages) as tblpages, heappages,
+      toastpages, reltuples, toasttuples, bs, page_hdr, tblid, schemaname, tblname, fillfactor, is_na
+      -- , tpl_hdr_size, tpl_data_size
+    from (
+      select
+        tbl.oid as tblid, 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 postgres_ai.pg_statistic as s on s.schemaname=ns.nspname
+          and s.tablename = tbl.relname and s.inherited=false 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')
+      group by 1,2,3,4,5,6,7,8,9,10
+      order by 2,3
+    ) as s
+  ) as s2
+) as s3
+-- where not is_na
+--   and tblpages*((pst).free_percent + (pst).dead_tuple_percent)::float4/100 >= 1
+where (bs * tblpages::float / (1024 * 1024)) > 1 /* exclude tables below 1 MiB */
+order by is_na = 0 desc, bloat_pct desc
+limit 1000
+`
+    },
+    gauges: ["real_size_mib", "extra_size", "extra_pct", "fillfactor", "bloat_size", "bloat_pct", "is_na", "reltuples"],
+    statement_timeout_seconds: 300
+  },
+  pg_btree_bloat: {
+    description: "This metric analyzes estimated index bloat by calculating the estimated vs actual index pages and sizes. It provides insights into estimated bloat percentage, real size, extra size due to estimated bloat, and estimated bloat size considering fill factor. This metric helps administrators identify indexes that may need maintenance like VACUUM FULL or index reorganization.",
+    sqls: {
+      11: `select /* pgwatch_generated */
+  current_database() as tag_datname, nspname as tag_schemaname, tblname as tag_tblname, idxname as tag_idxname,
+  (bs*(relpages)/(1024*1024))::float as real_size_mib,
+  (pg_relation_size(tbloid)/(1024*1024))::float as table_size_mib,
+  (bs*(relpages-est_pages))::float as extra_size,
+  100 * (relpages-est_pages)::float / relpages as extra_pct,
+  fillfactor,
+  case when relpages > est_pages_ff
+    then bs*(relpages-est_pages_ff)
+    else 0
+  end as bloat_size,
+  100 * (relpages-est_pages_ff)::float / relpages as bloat_pct,
+  is_na
+  -- , 100-(pst).avg_leaf_density as pst_avg_bloat, est_pages, index_tuple_hdr_bm, maxalign, pagehdr, nulldatawidth, nulldatahdrwidth, reltuples, relpages -- (DEBUG INFO)
+from (
+  select coalesce(1 +
+        ceil(reltuples/floor((bs-pageopqdata-pagehdr)/(4+nulldatahdrwidth)::float)), 0 -- ItemIdData size + computed avg size of a tuple (nulldatahdrwidth)
+      ) 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
+      -- , pgstatindex(idxoid) as pst, index_tuple_hdr_bm, maxalign, pagehdr, nulldatawidth, nulldatahdrwidth, reltuples -- (DEBUG INFO)
+  from (
+      select maxalign, bs, nspname, tblname, idxname, reltuples, relpages, idxoid, fillfactor, tbloid,
+            ( index_tuple_hdr_bm +
+                maxalign - case -- Add padding to the index tuple header to align on MAXALIGN
+                  when index_tuple_hdr_bm%maxalign = 0 then maxalign
+                  else index_tuple_hdr_bm%maxalign
+                end
+              + nulldatawidth + maxalign - case -- Add padding to the data to align on MAXALIGN
+                  when nulldatawidth = 0 then 0
+                  when nulldatawidth::integer%maxalign = 0 then maxalign
+                  else nulldatawidth::integer%maxalign
+                end
+            )::numeric as nulldatahdrwidth, pagehdr, pageopqdata, is_na
+            -- , index_tuple_hdr_bm, nulldatawidth -- (DEBUG INFO)
+      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 -- MAXALIGN: 4 on 32bits, 8 on 64bits (and mingw32 ?)
+                when version() ~ 'mingw32' or version() ~ '64-bit|x86_64|ppc64|ia64|amd64' then 8
+                else 4
+              end as maxalign,
+              /* per page header, fixed size: 20 for 7.X, 24 for others */
+              24 as pagehdr,
+              /* per page btree opaque data */
+              16 as pageopqdata,
+              /* per tuple header: add IndexAttributeBitMapData if some cols are null-able */
+              case when max(coalesce(s.null_frac,0)) = 0
+                  then 8 -- IndexTupleData size
+                  else 8 + (( 32 + 8 - 1 ) / 8) -- IndexTupleData size + IndexAttributeBitMapData size ( max num filed per index + 8 - 1 /8)
+              end as index_tuple_hdr_bm,
+              /* data len: we remove null values save space using it fractionnal part from stats */
+              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,
+                      pg_catalog.generate_series(1,indnatts) 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.indnatts,
+                          pg_catalog.string_to_array(pg_catalog.textin(
+                              pg_catalog.int2vectorout(i.indkey)),' ')::int[] as indkey
+                      from pg_catalog.pg_index i
+                      join pg_catalog.pg_class ci on ci.oid = i.indexrelid
+                      where ci.relam=(select oid from pg_am where amname = 'btree')
+                      and ci.relpages > 0
+                  ) as idx_data
+              ) as ic
+              join pg_catalog.pg_class ct on ct.oid = ic.tbloid
+              left join pg_catalog.pg_attribute a1 on
+                  ic.indkey[ic.attpos] <> 0
+                  and a1.attrelid = ic.tbloid
+                  and a1.attnum = ic.indkey[ic.attpos]
+              left join pg_catalog.pg_attribute a2 on
+                  ic.indkey[ic.attpos] = 0
+                  and a2.attrelid = ic.idxoid
+                  and a2.attnum = ic.attpos
+            ) i
+            join pg_catalog.pg_namespace n on n.oid = i.relnamespace
+                        join postgres_ai.pg_statistic s on s.schemaname = n.nspname
+                              and s.tablename = i.attrelname
+                              and s.attname = i.attname
+            group by 1,2,3,4,5,6,7,8,9,10,11,12
+      ) as rows_data_stats
+  ) as rows_hdr_pdg_stats
+) as relation_stats
+where (bs * relpages::float / (1024 * 1024)) > 1 /* exclude indexes below 1 MiB */
+order by is_na = 0 desc, bloat_pct desc
+limit 1000
+`
+    },
+    gauges: ["real_size_mib", "table_size_mib", "extra_size", "extra_pct", "fillfactor", "bloat_size", "bloat_pct", "is_na", "reltuples"],
+    statement_timeout_seconds: 15
   }
 };
 
@@ -26545,6 +26730,8 @@ var METRIC_NAMES = {
   H001: "pg_invalid_indexes",
   H002: "unused_indexes",
   H004: "redundant_indexes",
+  F004: "pg_table_bloat",
+  F005: "pg_btree_bloat",
   settings: "settings",
   dbStats: "db_stats",
   dbSize: "db_size",
@@ -27805,6 +27992,149 @@ async function generateF001(client, nodeName) {
   };
   return report;
 }
+async function generateF004(client, nodeName) {
+  const report = createBaseReport("F004", "Autovacuum: heap bloat (estimated)", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10);
+  let bloatedTables = [];
+  try {
+    const sql = getMetricSql(METRIC_NAMES.F004, pgMajorVersion);
+    const bloatResult = await client.query(sql);
+    const vacuumStatsResult = await client.query(`
+      SELECT schemaname, relname, last_vacuum, last_autovacuum
+      FROM pg_stat_user_tables
+    `);
+    const vacuumStats = new Map;
+    for (const row of vacuumStatsResult.rows) {
+      const key = `${row.schemaname}.${row.relname}`;
+      const vacuumTime = row.last_vacuum || row.last_autovacuum;
+      vacuumStats.set(key, {
+        last_vacuum: vacuumTime ? new Date(vacuumTime).toISOString() : null,
+        last_vacuum_epoch: vacuumTime ? Math.floor(new Date(vacuumTime).getTime() / 1000) : 0
+      });
+    }
+    bloatedTables = bloatResult.rows.map((row) => {
+      const t = transformMetricRow(row);
+      const schemaName = String(t.schemaname || "");
+      const tableName = String(t.tblname || "");
+      const realSizeBytes = Math.round((parseFloat(String(t.real_size_mib)) || 0) * 1024 * 1024);
+      const extraSize = parseInt(String(t.extra_size || 0), 10);
+      const bloatSize = parseInt(String(t.bloat_size || 0), 10);
+      const vacuumInfo = vacuumStats.get(`${schemaName}.${tableName}`) || {
+        last_vacuum: null,
+        last_vacuum_epoch: 0
+      };
+      return {
+        schema_name: schemaName,
+        table_name: tableName,
+        real_size: realSizeBytes,
+        extra_size: extraSize,
+        extra_pct: parseFloat(String(t.extra_pct)) || 0,
+        bloat_size: bloatSize,
+        bloat_pct: parseFloat(String(t.bloat_pct)) || 0,
+        fillfactor: parseInt(String(t.fillfactor || 100), 10),
+        last_vacuum: vacuumInfo.last_vacuum,
+        last_vacuum_epoch: vacuumInfo.last_vacuum_epoch,
+        real_size_pretty: formatBytes(realSizeBytes),
+        extra_size_pretty: formatBytes(extraSize),
+        bloat_size_pretty: formatBytes(bloatSize)
+      };
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F004] Error estimating table bloat: ${errorMsg}`);
+  }
+  const { datname: dbName, size_bytes: dbSizeBytes } = await getCurrentDatabaseInfo(client, pgMajorVersion);
+  const totalCount = bloatedTables.length;
+  const totalBloatSizeBytes = bloatedTables.reduce((sum, t) => sum + t.bloat_size, 0);
+  const dbEntry = {
+    bloated_tables: bloatedTables,
+    total_count: totalCount,
+    total_bloat_size_bytes: totalBloatSizeBytes,
+    total_bloat_size_pretty: formatBytes(totalBloatSizeBytes),
+    database_size_bytes: dbSizeBytes,
+    database_size_pretty: formatBytes(dbSizeBytes)
+  };
+  report.results[nodeName] = {
+    data: { [dbName]: dbEntry },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
+async function generateF005(client, nodeName) {
+  const report = createBaseReport("F005", "Autovacuum: index bloat (estimated)", nodeName);
+  const postgresVersion = await getPostgresVersion(client);
+  const pgMajorVersion = parseInt(postgresVersion.server_major_ver, 10);
+  let bloatedIndexes = [];
+  try {
+    const sql = getMetricSql(METRIC_NAMES.F005, pgMajorVersion);
+    const bloatResult = await client.query(sql);
+    const vacuumStatsResult = await client.query(`
+      SELECT schemaname, relname, last_vacuum, last_autovacuum
+      FROM pg_stat_user_tables
+    `);
+    const vacuumStats = new Map;
+    for (const row of vacuumStatsResult.rows) {
+      const key = `${row.schemaname}.${row.relname}`;
+      const vacuumTime = row.last_vacuum || row.last_autovacuum;
+      vacuumStats.set(key, {
+        last_vacuum: vacuumTime ? new Date(vacuumTime).toISOString() : null,
+        last_vacuum_epoch: vacuumTime ? Math.floor(new Date(vacuumTime).getTime() / 1000) : 0
+      });
+    }
+    bloatedIndexes = bloatResult.rows.map((row) => {
+      const t = transformMetricRow(row);
+      const schemaName = String(t.schemaname || "");
+      const tableName = String(t.tblname || "");
+      const indexName = String(t.idxname || "");
+      const realSizeBytes = Math.round((parseFloat(String(t.real_size_mib)) || 0) * 1024 * 1024);
+      const tableSizeBytes = Math.round((parseFloat(String(t.table_size_mib)) || 0) * 1024 * 1024);
+      const extraSize = parseInt(String(t.extra_size || 0), 10);
+      const bloatSize = parseInt(String(t.bloat_size || 0), 10);
+      const vacuumInfo = vacuumStats.get(`${schemaName}.${tableName}`) || {
+        last_vacuum: null,
+        last_vacuum_epoch: 0
+      };
+      return {
+        schema_name: schemaName,
+        table_name: tableName,
+        index_name: indexName,
+        real_size: realSizeBytes,
+        table_size: tableSizeBytes,
+        extra_size: extraSize,
+        extra_pct: parseFloat(String(t.extra_pct)) || 0,
+        bloat_size: bloatSize,
+        bloat_pct: parseFloat(String(t.bloat_pct)) || 0,
+        fillfactor: parseInt(String(t.fillfactor || 90), 10),
+        last_vacuum: vacuumInfo.last_vacuum,
+        last_vacuum_epoch: vacuumInfo.last_vacuum_epoch,
+        real_size_pretty: formatBytes(realSizeBytes),
+        table_size_pretty: formatBytes(tableSizeBytes),
+        extra_size_pretty: formatBytes(extraSize),
+        bloat_size_pretty: formatBytes(bloatSize)
+      };
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    console.log(`[F005] Error estimating index bloat: ${errorMsg}`);
+  }
+  const { datname: dbName, size_bytes: dbSizeBytes } = await getCurrentDatabaseInfo(client, pgMajorVersion);
+  const totalCount = bloatedIndexes.length;
+  const totalBloatSizeBytes = bloatedIndexes.reduce((sum, idx) => sum + idx.bloat_size, 0);
+  const dbEntry = {
+    bloated_indexes: bloatedIndexes,
+    total_count: totalCount,
+    total_bloat_size_bytes: totalBloatSizeBytes,
+    total_bloat_size_pretty: formatBytes(totalBloatSizeBytes),
+    database_size_bytes: dbSizeBytes,
+    database_size_pretty: formatBytes(dbSizeBytes)
+  };
+  report.results[nodeName] = {
+    data: { [dbName]: dbEntry },
+    postgres_version: postgresVersion
+  };
+  return report;
+}
 async function generateG001(client, nodeName) {
   const report = createBaseReport("G001", "Memory-related settings", nodeName);
   const postgresVersion = await getPostgresVersion(client);
@@ -27955,6 +28285,8 @@ var REPORT_GENERATORS = {
   D001: generateD001,
   D004: generateD004,
   F001: generateF001,
+  F004: generateF004,
+  F005: generateF005,
   G001: generateG001,
   G003: generateG003,
   H001: generateH001,
@@ -28472,6 +28804,15 @@ function summarizeG003(nodeData) {
 }
 
 // bin/postgres-ai.ts
+var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 18) {
+  console.error(`\x1B[31mError: postgresai requires Node 18 or higher.\x1B[0m`);
+  console.error(`You are running Node.js ${process.versions.node}.`);
+  console.error(`Please upgrade to Node.js 20 LTS or Node.js 22 for security updates.`);
+  console.error(`
+Download: https://nodejs.org/`);
+  process.exit(1);
+}
 var rl = null;
 function getReadline() {
   if (!rl) {
@@ -30031,6 +30372,64 @@ function checkRunningContainers() {
     return { running: false, containers: [] };
   }
 }
+function registerMonitoringInstance(apiKey, projectName, opts) {
+  const { apiBaseUrl } = resolveBaseUrls2(opts);
+  const url = `${apiBaseUrl}/rpc/monitoring_instance_register`;
+  const debug = opts?.debug;
+  if (debug) {
+    console.log(`
+Debug: Registering monitoring instance...`);
+    console.log(`Debug: POST ${url}`);
+    console.log(`Debug: project_name=${projectName}`);
+  }
+  fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      api_token: apiKey,
+      project_name: projectName
+    })
+  }).then(async (res) => {
+    const body = await res.text().catch(() => "");
+    if (!res.ok) {
+      if (debug) {
+        console.log(`Debug: Monitoring registration failed: HTTP ${res.status}`);
+        console.log(`Debug: Response: ${body}`);
+      }
+      return;
+    }
+    if (debug) {
+      console.log(`Debug: Monitoring registration response: ${body}`);
+    }
+  }).catch((err) => {
+    if (debug) {
+      console.log(`Debug: Monitoring registration error: ${err.message}`);
+    }
+  });
+}
+function updatePgwatchConfig(configPath, updates) {
+  let lines = [];
+  if (fs5.existsSync(configPath)) {
+    const stats = fs5.statSync(configPath);
+    if (!stats.isDirectory()) {
+      const content = fs5.readFileSync(configPath, "utf8");
+      lines = content.split(/\r?\n/).filter((l) => l.trim() !== "");
+    }
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    const existingIndex = lines.findIndex((l) => l.startsWith(key + "="));
+    if (existingIndex >= 0) {
+      lines[existingIndex] = `${key}=${value}`;
+    } else {
+      lines.push(`${key}=${value}`);
+    }
+  }
+  fs5.writeFileSync(configPath, lines.join(`
+`) + `
+`, { encoding: "utf8", mode: 384 });
+}
 async function runCompose(args, grafanaPassword) {
   let composeFile;
   let projectDir;
@@ -30092,9 +30491,9 @@ program2.command("help", { isDefault: true }).description("show help").action(()
   program2.outputHelp();
 });
 var mon = program2.command("mon").description("monitoring services management");
-mon.command("local-install").description("install local monitoring stack (generate config, start services)").option("--demo", "demo mode with sample database", false).option("--api-key <key>", "Postgres AI API key for automated report uploads").option("--db-url <url>", "PostgreSQL connection URL to monitor").option("--tag <tag>", "Docker image tag to use (e.g., 0.14.0, 0.14.0-dev.33)").option("-y, --yes", "accept all defaults and skip interactive prompts", false).action(async (opts) => {
+mon.command("local-install").description("install local monitoring stack (generate config, start services)").option("--demo", "demo mode with sample database", false).option("--api-key <key>", "Postgres AI API key for automated report uploads").option("--db-url <url>", "PostgreSQL connection URL to monitor").option("--tag <tag>", "Docker image tag to use (e.g., 0.14.0, 0.14.0-dev.33)").option("--project <name>", "Docker Compose project name (default: postgres_ai)").option("-y, --yes", "accept all defaults and skip interactive prompts", false).action(async (opts) => {
   const globalOpts = program2.opts();
-  const apiKey = opts.apiKey || globalOpts.apiKey;
+  let apiKey = opts.apiKey || globalOpts.apiKey;
   console.log(`
 =================================`);
   console.log("  PostgresAI monitoring local install");
@@ -30105,6 +30504,12 @@ mon.command("local-install").description("install local monitoring stack (genera
   const { projectDir } = await resolveOrInitPaths();
   console.log(`Project directory: ${projectDir}
 `);
+  if (opts.project) {
+    const cfgPath2 = path5.resolve(projectDir, ".pgwatch-config");
+    updatePgwatchConfig(cfgPath2, { project_name: opts.project });
+    console.log(`Using project name: ${opts.project}
+`);
+  }
   const envFile = path5.resolve(projectDir, ".env");
   let existingRegistry = null;
   let existingPassword = null;
@@ -30161,11 +30566,7 @@ Use demo mode without API key: postgres-ai mon local-install --demo`);
     if (apiKey) {
       console.log("Using API key provided via --api-key parameter");
       writeConfig({ apiKey });
-      fs5.writeFileSync(path5.resolve(projectDir, ".pgwatch-config"), `api_key=${apiKey}
-`, {
-        encoding: "utf8",
-        mode: 384
-      });
+      updatePgwatchConfig(path5.resolve(projectDir, ".pgwatch-config"), { api_key: apiKey });
       console.log(`\u2713 API key saved
 `);
     } else if (opts.yes) {
@@ -30182,11 +30583,8 @@ 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}
-`, {
-              encoding: "utf8",
-              mode: 384
-            });
+            updatePgwatchConfig(path5.resolve(projectDir, ".pgwatch-config"), { api_key: trimmedKey });
+            apiKey = trimmedKey;
             console.log(`\u2713 API key saved
 `);
             break;
@@ -30393,6 +30791,13 @@ You can provide either:`);
   }
   console.log(`\u2713 Services started
 `);
+  if (apiKey && !opts.demo) {
+    const projectName = opts.project || "postgres-ai-monitoring";
+    registerMonitoringInstance(apiKey, projectName, {
+      apiBaseUrl: globalOpts.apiBaseUrl,
+      debug: !!process.env.DEBUG
+    });
+  }
   console.log("=================================");
   console.log("  Local install completed!");
   console.log(`=================================