@danielarndt0/cnpj-db-loader 2.3.1 → 2.4.0-beta.1

package/dist/cli.js

@@ -3237,6 +3237,15 @@ function createFieldValueParser(dataType) {
       };
   }
 }
+function toDatabaseValue(dataType, rawValue) {
+  return createFieldValueParser(dataType)(rawValue);
+}
+function normalizeCode(value, fallback) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value.trim();
+  }
+  return fallback;
+}
 function createPartnerDedupeKeyBuilder(indices) {
   const orderedIndices = [
     indices.cnpjRoot,
@@ -3264,6 +3273,60 @@ function createEstablishmentCnpjFullBuilder(indices) {
     return `${root}${order}${digits}`;
   };
 }
+function buildPartnerDedupeKey(recordByColumn) {
+  return [
+    recordByColumn.cnpj_root,
+    recordByColumn.partner_type_code,
+    recordByColumn.partner_name,
+    recordByColumn.partner_document,
+    recordByColumn.partner_qualification_code,
+    recordByColumn.entry_date,
+    recordByColumn.country_code,
+    recordByColumn.legal_representative_document,
+    recordByColumn.legal_representative_name,
+    recordByColumn.legal_representative_qualification_code,
+    recordByColumn.age_group_code
+  ].map((value) => value == null ? "" : String(value).trim()).join("|");
+}
+function transformRecord(dataset, layout, rawFields, schemaCapabilities, writeTarget) {
+  const values = layout.fields.map(
+    (field, index) => toDatabaseValue(field.dataType, rawFields[index] ?? "")
+  );
+  const recordByColumn = Object.fromEntries(
+    layout.fields.map((field, index) => [field.columnName, values[index]])
+  );
+  if (dataset === "companies") {
+    recordByColumn.company_size_code = normalizeCode(
+      recordByColumn.company_size_code,
+      "00"
+    );
+  }
+  if (dataset === "establishments") {
+    recordByColumn.branch_type_code = normalizeCode(
+      recordByColumn.branch_type_code,
+      "1"
+    );
+    recordByColumn.registration_status_code = normalizeCode(
+      recordByColumn.registration_status_code,
+      "01"
+    );
+  }
+  const normalizedValues = layout.fields.map(
+    (field) => recordByColumn[field.columnName]
+  );
+  if (writeTarget === "final") {
+    if (dataset === "establishments" && schemaCapabilities.includeEstablishmentCnpjFullInInsert) {
+      return [
+        ...normalizedValues,
+        `${recordByColumn.cnpj_root ?? ""}${recordByColumn.cnpj_order ?? ""}${recordByColumn.cnpj_check_digits ?? ""}`
+      ];
+    }
+    if (dataset === "partners" && schemaCapabilities.includePartnerDedupeKeyInInsert) {
+      return [...normalizedValues, buildPartnerDedupeKey(recordByColumn)];
+    }
+  }
+  return normalizedValues;
+}
 function buildParsedPayload(columns, values) {
   return Object.fromEntries(
     columns.map((column, index) => [column, values[index] ?? null])
@@ -3403,7 +3466,7 @@ function createImportRowNormalizer(input2) {
       "cnpj_check_digits"
     )
   }) : null;
-  const buildPartnerDedupeKey = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
+  const buildPartnerDedupeKey2 = appendPartnerDedupeKey ? createPartnerDedupeKeyBuilder({
     cnpjRoot: resolveLayoutColumnIndex(input2.layout, "cnpj_root"),
     partnerTypeCode: resolveLayoutColumnIndex(
       input2.layout,
@@ -3463,8 +3526,8 @@ function createImportRowNormalizer(input2) {
       if (buildEstablishmentCnpjFull) {
         values.push(buildEstablishmentCnpjFull(values));
       }
-      if (buildPartnerDedupeKey) {
-        values.push(buildPartnerDedupeKey(values));
+      if (buildPartnerDedupeKey2) {
+        values.push(buildPartnerDedupeKey2(values));
       }
       return {
         values,
@@ -8065,6 +8128,851 @@ async function syncFederalRevenueDataset(options = {}) {
   );
 }
 
+// src/services/postgres-direct/exporter.ts
+import { createWriteStream as createWriteStream3 } from "fs";
+import { mkdir as mkdir8, writeFile as writeFile5 } from "fs/promises";
+import path16 from "path";
+
+// src/services/postgres-direct/csv.ts
+function formatCsvValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return formatCsvValue(value.toISOString());
+  }
+  const text = String(value);
+  const shouldQuote = /[",\r\n]/.test(text);
+  if (!shouldQuote) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '""')}"`;
+}
+function formatCsvRow(values) {
+  return values.map(formatCsvValue).join(",");
+}
+
+// src/services/postgres-direct/script.ts
+import path15 from "path";
+var STAGING_DATASETS = [
+  "companies",
+  "establishments",
+  "partners",
+  "simples_options"
+];
+var DOMAIN_DATASETS = [
+  "partner_qualifications",
+  "legal_natures",
+  "countries",
+  "cities",
+  "reasons",
+  "cnaes"
+];
+var STAGING_TABLE_BY_DATASET3 = {
+  companies: "staging_companies",
+  establishments: "staging_establishments",
+  partners: "staging_partners",
+  simples_options: "staging_simples_options"
+};
+function quoteSqlLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function normalizePathForPsql(filePath) {
+  return path15.resolve(filePath).replace(/\\/g, "/");
+}
+function csvCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header true, delimiter ',', quote '"', escape '"', null '')`;
+}
+function receitaCopyCommand(tableName, columns, filePath) {
+  const normalizedFilePath = normalizePathForPsql(filePath);
+  return `\\copy ${tableName} (${columns.join(", ")}) from ${quoteSqlLiteral(normalizedFilePath)} with (format csv, header false, delimiter ';', quote '"', escape '"')`;
+}
+function datasetColumns(dataset) {
+  return DATASET_LAYOUTS[dataset].fields.map((field) => field.columnName);
+}
+function updateAssignments(columns, excludedColumns) {
+  return columns.filter((column) => !excludedColumns.includes(column)).map((column) => `${column} = excluded.${column}`).concat(["updated_at = now()"]).join(",\n  ");
+}
+function partnerDedupeExpression(alias) {
+  return [
+    "md5(",
+    `  coalesce(${alias}.cnpj_root, '') || '|' ||`,
+    `  coalesce(${alias}.partner_type_code, '') || '|' ||`,
+    `  coalesce(${alias}.partner_name, '') || '|' ||`,
+    `  coalesce(${alias}.partner_document, '') || '|' ||`,
+    `  coalesce(${alias}.partner_qualification_code, '') || '|' ||`,
+    `  coalesce((${alias}.entry_date - date '2000-01-01')::text, '') || '|' ||`,
+    `  coalesce(${alias}.country_code, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_document, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_name, '') || '|' ||`,
+    `  coalesce(${alias}.legal_representative_qualification_code, '') || '|' ||`,
+    `  coalesce(${alias}.age_group_code, '')`,
+    ")"
+  ].join("\n");
+}
+function materializeCompaniesSql() {
+  const columns = companiesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing companies...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_companies source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into companies (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function materializeEstablishmentsSql() {
+  const baseColumns = establishmentsLayout.fields.map(
+    (field) => field.columnName
+  );
+  const insertColumns = [...baseColumns, "cnpj_full"];
+  return [
+    "\\echo 'Materializing establishments and secondary CNAEs...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    source.cnpj_root || source.cnpj_order || source.cnpj_check_digits as cnpj_full,",
+    "    row_number() over (partition by source.cnpj_root || source.cnpj_order || source.cnpj_check_digits order by source.staging_id desc) as dedupe_rank",
+    "  from staging_establishments source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    "),",
+    "upserted as (",
+    `  insert into establishments (${insertColumns.join(", ")})`,
+    `  select ${insertColumns.join(", ")}`,
+    "  from deduped",
+    "  on conflict (cnpj_full) do update set",
+    `    ${updateAssignments(insertColumns, ["cnpj_root", "cnpj_order", "cnpj_check_digits", "cnpj_full"])}`,
+    "  returning cnpj_full",
+    "),",
+    "deleted_secondary_cnaes as (",
+    "  delete from establishment_secondary_cnaes target",
+    "  using (select cnpj_full from deduped) source_keys",
+    "  where target.cnpj_full = source_keys.cnpj_full",
+    "  returning 1",
+    "),",
+    "secondary_cnaes_source as (",
+    "  select distinct",
+    "    deduped.cnpj_full,",
+    "    btrim(cnae_code) as cnae_code",
+    "  from deduped",
+    "  cross join lateral unnest(string_to_array(deduped.secondary_cnaes_raw, ',')) as cnae_code",
+    "  where deduped.secondary_cnaes_raw is not null",
+    "    and deduped.secondary_cnaes_raw <> ''",
+    "    and btrim(cnae_code) <> ''",
+    ")",
+    "insert into establishment_secondary_cnaes (cnpj_full, cnae_code)",
+    "select cnpj_full, cnae_code",
+    "from secondary_cnaes_source",
+    "on conflict (cnpj_full, cnae_code) do nothing;"
+  ].join("\n");
+}
+function materializePartnersSql() {
+  const baseColumns = partnersLayout.fields.map((field) => field.columnName);
+  const insertColumns = [...baseColumns, "partner_dedupe_key"];
+  return [
+    "\\echo 'Materializing partners...'",
+    "with source as (",
+    "  select",
+    `    ${baseColumns.map((column) => `source.${column}`).join(",\n    ")},`,
+    `    ${partnerDedupeExpression("source")} as partner_dedupe_key`,
+    "  from staging_partners source",
+    "),",
+    "ranked as (",
+    "  select",
+    "    source.*,",
+    "    row_number() over (partition by source.partner_dedupe_key order by source.cnpj_root asc) as dedupe_rank",
+    "  from source",
+    "),",
+    "deduped as (",
+    "  select * from ranked where dedupe_rank = 1",
+    ")",
+    `insert into partners (${insertColumns.join(", ")})`,
+    `select ${insertColumns.join(", ")}`,
+    "from deduped",
+    "on conflict (partner_dedupe_key) do update set",
+    `  ${updateAssignments(insertColumns, ["partner_dedupe_key"])};`
+  ].join("\n");
+}
+function materializeSimplesSql() {
+  const columns = simplesLayout.fields.map((field) => field.columnName);
+  return [
+    "\\echo 'Materializing simples options...'",
+    "with source as (",
+    "  select",
+    `    ${columns.map((column) => `source.${column}`).join(",\n    ")},`,
+    "    row_number() over (partition by source.cnpj_root order by source.staging_id desc) as dedupe_rank",
+    "  from staging_simples_options source",
+    "),",
+    "deduped as (",
+    "  select * from source where dedupe_rank = 1",
+    ")",
+    `insert into simples_options (${columns.join(", ")})`,
+    `select ${columns.join(", ")}`,
+    "from deduped",
+    "on conflict (cnpj_root) do update set",
+    `  ${updateAssignments(columns, ["cnpj_root"])};`
+  ].join("\n");
+}
+function copyDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const columns = datasetColumns(dataset);
+  const tempTable = `tmp_hybrid_${dataset}`;
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data...'`,
+    `drop table if exists ${tempTable};`,
+    `create temporary table ${tempTable} (code text, description text);`
+  ];
+  for (const file of files) {
+    lines.push(csvCopyCommand(tempTable, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    `select distinct on (code) ${columns.join(", ")}`,
+    `from ${tempTable}`,
+    "where code is not null and code <> ''",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
+}
+function copyStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const tableName = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!tableName) {
+    return [];
+  }
+  const columns = datasetColumns(dataset);
+  return [
+    `\\echo 'Loading ${dataset} staging data...'`,
+    ...files.map(
+      (file) => csvCopyCommand(tableName, columns, file.absolutePath)
+    )
+  ];
+}
+function csvFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
+  }
+  return grouped;
+}
+function directFilesByDataset(files) {
+  const grouped = {};
+  for (const file of files) {
+    const items = grouped[file.dataset] ?? [];
+    items.push(file);
+    grouped[file.dataset] = items;
+  }
+  return grouped;
+}
+function rawTableName(dataset) {
+  return `tmp_hybrid_raw_${dataset}`;
+}
+function createRawTempTableSql(dataset) {
+  const columns = DATASET_LAYOUTS[dataset].fields.map((field) => `  ${quoteIdentifier(field.columnName)} text`).join(",\n");
+  return [
+    `drop table if exists ${rawTableName(dataset)};`,
+    `create temporary table ${rawTableName(dataset)} (`,
+    columns,
+    ");"
+  ].join("\n");
+}
+function textExpression(alias, column) {
+  return `nullif(btrim(${alias}.${quoteIdentifier(column)}), '')`;
+}
+function dateExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' or ${value} = '00000000' then null`,
+    `  when ${value} ~ '^\\d{8}$' then to_date(${value}, 'YYYYMMDD')`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function numericExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} like '%,%' and ${value} like '%.%' then replace(replace(${value}, '.', ''), ',', '.')::numeric`,
+    `  when ${value} like '%,%' then replace(${value}, ',', '.')::numeric`,
+    `  else ${value}::numeric`,
+    "end"
+  ].join(" ");
+}
+function integerExpression(alias, column) {
+  const value = `btrim(${alias}.${quoteIdentifier(column)})`;
+  return [
+    "case",
+    `  when ${value} = '' then null`,
+    `  when ${value} ~ '^-?\\d+$' then ${value}::integer`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function booleanExpression(alias, column) {
+  const value = `lower(btrim(${alias}.${quoteIdentifier(column)}))`;
+  return [
+    "case",
+    `  when ${value} in ('1', 'true', 't', 'y', 'yes', 's') then true`,
+    `  when ${value} in ('0', 'false', 'f', 'n', 'no') then false`,
+    "  else null",
+    "end"
+  ].join(" ");
+}
+function fieldExpression(dataset, field, alias) {
+  const column = field.columnName;
+  if (dataset === "companies" && column === "company_size_code") {
+    return `coalesce(${textExpression(alias, column)}, '00')`;
+  }
+  if (dataset === "establishments" && column === "branch_type_code") {
+    return `coalesce(${textExpression(alias, column)}, '1')`;
+  }
+  if (dataset === "establishments" && column === "registration_status_code") {
+    return `coalesce(${textExpression(alias, column)}, '01')`;
+  }
+  switch (field.dataType) {
+    case "date":
+      return dateExpression(alias, column);
+    case "numeric":
+      return numericExpression(alias, column);
+    case "integer":
+      return integerExpression(alias, column);
+    case "boolean":
+      return booleanExpression(alias, column);
+    default:
+      return textExpression(alias, column);
+  }
+}
+function rawDomainSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const lines = [
+    `\\echo 'Loading ${dataset} lookup data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${dataset} (${columns.join(", ")})`,
+    "select distinct on (code)",
+    "  nullif(btrim(code), '') as code,",
+    "  nullif(btrim(description), '') as description",
+    `from ${tableName}`,
+    "where nullif(btrim(code), '') is not null",
+    "order by code",
+    "on conflict (code) do update set description = excluded.description;"
+  );
+  return lines;
+}
+function rawStagingSql(dataset, files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const targetTable = STAGING_TABLE_BY_DATASET3[dataset];
+  if (!targetTable) {
+    return [];
+  }
+  const layout = DATASET_LAYOUTS[dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  const tableName = rawTableName(dataset);
+  const alias = "source";
+  const expressions = layout.fields.map(
+    (field) => `  ${fieldExpression(dataset, field, alias)} as ${field.columnName}`
+  );
+  const lines = [
+    `\\echo 'Loading ${dataset} staging data directly from sanitized Receita files...'`,
+    createRawTempTableSql(dataset)
+  ];
+  for (const file of files) {
+    lines.push(receitaCopyCommand(tableName, columns, file.absolutePath));
+  }
+  lines.push(
+    `insert into ${targetTable} (${columns.join(", ")})`,
+    "select",
+    expressions.join(",\n"),
+    `from ${tableName} ${alias};`
+  );
+  return lines;
+}
+function generatePostgresDirectImportScript(input2) {
+  const grouped = csvFilesByDataset(input2.files);
+  const lines = [
+    "-- CNPJ DB Loader hybrid PostgreSQL import script",
+    "-- Generated from PostgreSQL-ready CSV files exported by cnpj-db-loader postgres export-csv.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    "\\echo 'Starting CNPJ DB Loader hybrid PostgreSQL import...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script only resets staging tables and then upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...copyDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...copyStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function generatePostgresSanitizedDirectImportScript(input2) {
+  const grouped = directFilesByDataset(input2.files);
+  const lines = [
+    "-- CNPJ DB Loader direct PostgreSQL import script",
+    "-- Generated from sanitized Receita files by cnpj-db-loader postgres generate-script.",
+    "-- This path avoids rewriting the dataset into a second CSV tree.",
+    "-- Execute with psql, for example:",
+    '--   psql "postgres://postgres:postgres@localhost:5432/cnpj" -f import-postgres-direct.sql',
+    "",
+    "\\set ON_ERROR_STOP on",
+    `\\echo 'Using source file encoding ${input2.sourceEncoding} for psql copy operations...'`,
+    `set client_encoding to ${quoteSqlLiteral(input2.sourceEncoding)};`,
+    "\\echo 'Starting CNPJ DB Loader direct PostgreSQL import from sanitized files...'",
+    "",
+    "begin;",
+    "",
+    "-- Keep the final schema and seed data managed by sql/schema.sql.",
+    "-- This script copies sanitized Receita files into temporary raw tables,",
+    "-- transforms values inside PostgreSQL, resets staging tables and upserts final data.",
+    "truncate table staging_companies restart identity;",
+    "truncate table staging_establishments restart identity;",
+    "truncate table staging_partners restart identity;",
+    "truncate table staging_simples_options restart identity;",
+    ""
+  ];
+  for (const dataset of DOMAIN_DATASETS) {
+    lines.push(...rawDomainSql(dataset, grouped[dataset] ?? []), "");
+  }
+  for (const dataset of STAGING_DATASETS) {
+    lines.push(...rawStagingSql(dataset, grouped[dataset] ?? []), "");
+  }
+  lines.push(...materializationAndAnalyzeSql());
+  return lines.join("\n");
+}
+function materializationAndAnalyzeSql() {
+  return [
+    materializeCompaniesSql(),
+    "",
+    materializeEstablishmentsSql(),
+    "",
+    materializePartnersSql(),
+    "",
+    materializeSimplesSql(),
+    "",
+    "\\echo 'Refreshing planner statistics...'",
+    "analyze companies;",
+    "analyze establishments;",
+    "analyze establishment_secondary_cnaes;",
+    "analyze partners;",
+    "analyze simples_options;",
+    "analyze cnaes;",
+    "analyze cities;",
+    "analyze countries;",
+    "analyze legal_natures;",
+    "analyze partner_qualifications;",
+    "analyze reasons;",
+    "",
+    "commit;",
+    "",
+    "\\echo 'CNPJ DB Loader hybrid PostgreSQL import completed.'",
+    ""
+  ];
+}
+
+// src/services/postgres-direct/exporter.ts
+var POSTGRES_DIRECT_SCHEMA_CAPABILITIES = {
+  includeEstablishmentCnpjFullInInsert: true,
+  includeEstablishmentSecondaryCnaesTable: true,
+  includePartnerDedupeKeyInInsert: true,
+  requiresLookupReconciliation: false
+};
+function defaultPostgresCsvOutputPath(inputPath) {
+  const baseName = path16.basename(inputPath);
+  return path16.join(path16.dirname(inputPath), `${baseName}-postgres-csv`);
+}
+function normalizeOutputFileName(relativePath) {
+  const parsed = path16.parse(relativePath);
+  const baseName = parsed.name || parsed.base || "dataset";
+  return path16.join(parsed.dir, `${baseName}.csv`);
+}
+function resolveDatasetOutputPath(outputPath, dataset, relativePath) {
+  return path16.join(outputPath, dataset, normalizeOutputFileName(relativePath));
+}
+function inferNextStep4(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+async function writeCsvFile(input2) {
+  const layout = DATASET_LAYOUTS[input2.dataset];
+  const columns = layout.fields.map((field) => field.columnName);
+  await mkdir8(path16.dirname(input2.outputFile), { recursive: true });
+  const output2 = createWriteStream3(input2.outputFile, { encoding: "utf8" });
+  let rows = 0;
+  try {
+    output2.write(`${formatCsvRow(columns)}
+`);
+    for await (const sourceLine of readImportSourceLines(input2.inputFile)) {
+      if (sourceLine.rawLine.trim() === "") {
+        continue;
+      }
+      const parsed = parseImportSourceLine(sourceLine);
+      const normalizedFields = normalizeFieldCount(
+        parsed.fields,
+        layout.fields.length,
+        input2.inputFile,
+        parsed.lineNumber
+      );
+      const values = transformRecord(
+        input2.dataset,
+        layout,
+        normalizedFields,
+        POSTGRES_DIRECT_SCHEMA_CAPABILITIES,
+        "staging"
+      );
+      output2.write(`${formatCsvRow(values)}
+`);
+      rows += 1;
+    }
+  } finally {
+    output2.end();
+    await new Promise((resolve2, reject) => {
+      output2.on("finish", () => resolve2());
+      output2.on("error", (error) => reject(error));
+    });
+  }
+  return rows;
+}
+async function exportPostgresCsvDataset(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL CSV export. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.validatedPath;
+  const outputPath = path16.resolve(
+    options.outputPath ?? defaultPostgresCsvOutputPath(validatedPath)
+  );
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL CSV export."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets
+  });
+  const exportedFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const inputFile = path16.join(validatedPath, entry.relativePath);
+    const outputFile = resolveDatasetOutputPath(
+      outputPath,
+      dataset,
+      entry.relativePath
+    );
+    options.onProgress?.({
+      kind: "file_start",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile
+    });
+    const rowCount = await writeCsvFile({ dataset, inputFile, outputFile });
+    exportedFiles.push({
+      dataset,
+      absolutePath: outputFile,
+      relativePath: path16.relative(outputPath, outputFile),
+      rowCount
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      rows: 0,
+      outputFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.rows += rowCount;
+    currentSummary.outputFiles.push(outputFile);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_finish",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(inputFile),
+      outputFile,
+      rows: rowCount
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path16.join(outputPath, scriptName);
+  const script = generatePostgresDirectImportScript({ files: exportedFiles });
+  await writeFile5(scriptPath, script, "utf8");
+  const manifestPath = path16.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalRows = summaryDatasets.reduce((sum, item) => sum + item.rows, 0);
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets
+  };
+  await writeFile5(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: exportedFiles.length,
+    totalRows
+  });
+  return {
+    inputPath: path16.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    totalFiles: exportedFiles.length,
+    totalRows,
+    datasets: summaryDatasets,
+    warnings: [
+      "PostgreSQL-ready CSV export is intended for hybrid bulk imports after extraction, validation and sanitization.",
+      "The generated SQL script resets staging tables and then upserts final tables. Review it before running against production databases."
+    ],
+    nextStep: inferNextStep4(scriptPath)
+  };
+}
+
+// src/services/postgres-direct/generator.ts
+import { mkdir as mkdir9, stat as stat7, writeFile as writeFile6 } from "fs/promises";
+import path17 from "path";
+var DEFAULT_SOURCE_ENCODING = "WIN1252";
+function defaultPostgresDirectOutputPath(inputPath) {
+  const baseName = path17.basename(inputPath);
+  if (baseName.toLowerCase() === "sanitized") {
+    return path17.join(path17.dirname(inputPath), "postgres-direct");
+  }
+  return path17.join(path17.dirname(inputPath), `${baseName}-postgres-direct`);
+}
+function inferNextStep5(scriptPath) {
+  return `psql "postgres://postgres:postgres@localhost:5432/cnpj" -f ${scriptPath.replace(/\\/g, "/")}`;
+}
+function normalizeSourceEncoding(value) {
+  const encoding = (value ?? DEFAULT_SOURCE_ENCODING).trim();
+  if (!/^[A-Za-z0-9_-]+$/.test(encoding)) {
+    throw new ValidationError(
+      `Invalid source encoding: ${value}. Use a PostgreSQL client encoding name such as WIN1252 or UTF8.`
+    );
+  }
+  return encoding.toUpperCase();
+}
+async function generatePostgresDirectScript(inputPath, options = {}) {
+  if (options.dataset && !isImportDatasetType(options.dataset)) {
+    throw new ValidationError(`Unsupported dataset type: ${options.dataset}.`);
+  }
+  const validation = await validateInputDirectory(inputPath);
+  if (!validation.ok && !options.dataset) {
+    throw new ValidationError(
+      `The input directory is not ready for PostgreSQL direct script generation. ${validation.errors.join(" ")}`
+    );
+  }
+  const validatedPath = validation.ok ? validation.validatedPath : path17.resolve(inputPath);
+  const outputPath = path17.resolve(
+    options.outputPath ?? defaultPostgresDirectOutputPath(validatedPath)
+  );
+  const sourceEncoding = normalizeSourceEncoding(options.sourceEncoding);
+  const inspected = await inspectFiles(validatedPath);
+  const recognizedFiles = inspected.entries.filter((entry) => entry.entryKind === "file").flatMap((entry) => {
+    if (!isImportDatasetType(entry.inferredType)) {
+      return [];
+    }
+    if (options.dataset && entry.inferredType !== options.dataset) {
+      return [];
+    }
+    return [{ ...entry, inferredType: entry.inferredType }];
+  }).sort(sortEntries);
+  if (recognizedFiles.length === 0) {
+    throw new ValidationError(
+      "No recognized dataset files were found for PostgreSQL direct script generation."
+    );
+  }
+  const datasets = [
+    ...new Set(recognizedFiles.map((entry) => entry.inferredType))
+  ].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left) - IMPORT_ORDER.indexOf(right)
+  );
+  options.onProgress?.({
+    kind: "start",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    totalFiles: recognizedFiles.length,
+    datasets,
+    sourceEncoding
+  });
+  await mkdir9(outputPath, { recursive: true });
+  const sourceFiles = [];
+  const summariesByDataset = /* @__PURE__ */ new Map();
+  for (const [index, entry] of recognizedFiles.entries()) {
+    const dataset = entry.inferredType;
+    const absolutePath = path17.join(validatedPath, entry.relativePath);
+    const fileStats = await stat7(absolutePath);
+    sourceFiles.push({
+      dataset,
+      absolutePath,
+      relativePath: entry.relativePath,
+      fileSize: fileStats.size
+    });
+    const currentSummary = summariesByDataset.get(dataset) ?? {
+      dataset,
+      files: 0,
+      totalBytes: 0,
+      sourceFiles: []
+    };
+    currentSummary.files += 1;
+    currentSummary.totalBytes += fileStats.size;
+    currentSummary.sourceFiles.push(absolutePath);
+    summariesByDataset.set(dataset, currentSummary);
+    options.onProgress?.({
+      kind: "file_registered",
+      dataset,
+      fileIndex: index + 1,
+      totalFiles: recognizedFiles.length,
+      inputFile: buildDisplayPath(absolutePath),
+      fileSize: fileStats.size
+    });
+  }
+  const scriptName = options.scriptName ?? "import-postgres-direct.sql";
+  const scriptPath = path17.join(outputPath, scriptName);
+  const script = generatePostgresSanitizedDirectImportScript({
+    files: sourceFiles,
+    sourceEncoding
+  });
+  await writeFile6(scriptPath, script, "utf8");
+  const manifestPath = path17.join(outputPath, "manifest.json");
+  const summaryDatasets = [...summariesByDataset.values()].sort(
+    (left, right) => IMPORT_ORDER.indexOf(left.dataset) - IMPORT_ORDER.indexOf(right.dataset)
+  );
+  const totalBytes = summaryDatasets.reduce(
+    (sum, item) => sum + item.totalBytes,
+    0
+  );
+  const manifest = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: "direct-sanitized-script",
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets
+  };
+  await writeFile6(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}
+`,
+    "utf8"
+  );
+  options.onProgress?.({
+    kind: "finish",
+    outputPath,
+    scriptPath,
+    totalFiles: sourceFiles.length,
+    totalBytes
+  });
+  return {
+    inputPath: path17.resolve(inputPath),
+    validatedPath,
+    outputPath,
+    scriptPath,
+    manifestPath,
+    sourceEncoding,
+    totalFiles: sourceFiles.length,
+    totalBytes,
+    datasets: summaryDatasets,
+    warnings: [
+      ...validation.ok ? [] : validation.errors,
+      "This script imports sanitized Receita files directly with psql \\copy. It avoids rewriting the full dataset into a second CSV tree.",
+      "The generated script expects the database schema generated by cnpj-db-loader to be applied before execution.",
+      "Use --source-encoding UTF8 only if your sanitized files are already UTF-8. The default WIN1252 matches the usual Receita file encoding."
+    ],
+    nextStep: inferNextStep5(scriptPath)
+  };
+}
+
 // src/cli/ui/theme.ts
 var colorsEnabled = process.stdout.isTTY && !process.argv.includes("--no-color") && process.env.NO_COLOR === void 0;
 function paint(code, value) {
@@ -8114,9 +9022,9 @@ function handleCliError(error) {
 }
 
 // src/cli/ui/output/shared.ts
-import path15 from "path";
+import path18 from "path";
 function resolveLogFilePath(logFilePath) {
-  return path15.resolve(logFilePath);
+  return path18.resolve(logFilePath);
 }
 function formatKeyValue(label, value) {
   return `${theme.muted(`- ${label}:`)} ${value}`;
@@ -8656,6 +9564,59 @@ function printFederalRevenueSyncSummary(summary, logFilePath) {
     `${theme.muted("Import progress log:")} ${resolveLogFilePath(summary.import.progressLogPath)}`
   );
 }
+function printPostgresCsvExportSummary(summary, logFilePath) {
+  console.log(
+    theme.successLabel("POSTGRES"),
+    "PostgreSQL-ready CSV export completed."
+  );
+  console.log(formatKeyValue("Input path", summary.inputPath));
+  console.log(formatKeyValue("Validated path", summary.validatedPath));
+  console.log(formatKeyValue("Output path", summary.outputPath));
+  console.log(formatKeyValue("Generated script", summary.scriptPath));
+  console.log(formatKeyValue("Manifest", summary.manifestPath));
+  console.log(formatKeyValue("Exported files", summary.totalFiles));
+  console.log(formatKeyValue("Exported rows", formatCount(summary.totalRows)));
+  if (summary.datasets.length > 0) {
+    console.log(theme.infoLabel("DATASETS"));
+    for (const dataset of summary.datasets) {
+      console.log(
+        `  ${theme.blue("\u2022")} ${dataset.dataset}: ${dataset.files} file(s), ${formatCount(dataset.rows)} row(s)`
+      );
+    }
+  }
+  printWarnings(summary.warnings);
+  if (summary.nextStep) {
+    console.log(`${theme.infoLabel("NEXT")} ${summary.nextStep}`);
+  }
+  console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
+}
+function printPostgresDirectScriptSummary(summary, logFilePath) {
+  console.log(
+    theme.successLabel("POSTGRES"),
+    "Direct PostgreSQL import script generated."
+  );
+  console.log(formatKeyValue("Input path", summary.inputPath));
+  console.log(formatKeyValue("Validated path", summary.validatedPath));
+  console.log(formatKeyValue("Output path", summary.outputPath));
+  console.log(formatKeyValue("Generated script", summary.scriptPath));
+  console.log(formatKeyValue("Manifest", summary.manifestPath));
+  console.log(formatKeyValue("Source encoding", summary.sourceEncoding));
+  console.log(formatKeyValue("Source files", summary.totalFiles));
+  console.log(formatKeyValue("Source bytes", formatBytes(summary.totalBytes)));
+  if (summary.datasets.length > 0) {
+    console.log(theme.infoLabel("DATASETS"));
+    for (const dataset of summary.datasets) {
+      console.log(
+        `  ${theme.blue("\u2022")} ${dataset.dataset}: ${dataset.files} file(s), ${formatBytes(dataset.totalBytes)}`
+      );
+    }
+  }
+  printWarnings(summary.warnings);
+  if (summary.nextStep) {
+    console.log(`${theme.infoLabel("NEXT")} ${summary.nextStep}`);
+  }
+  console.log(`${theme.muted("Log file:")} ${resolveLogFilePath(logFilePath)}`);
+}
 
 // src/cli/ui/output/progress.ts
 function createExtractionProgressReporter() {
@@ -9276,6 +10237,65 @@ function createFederalRevenueDownloadProgressReporter() {
     );
   };
 }
+function createPostgresCsvExportProgressReporter() {
+  return (event) => {
+    if (event.kind === "start") {
+      console.log(
+        theme.infoLabel("POSTGRES"),
+        "Starting PostgreSQL-ready CSV export..."
+      );
+      console.log(formatKeyValue("Input path", event.inputPath));
+      console.log(formatKeyValue("Validated path", event.validatedPath));
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Files queued", event.totalFiles));
+      return;
+    }
+    if (event.kind === "file_finish") {
+      console.log(
+        `${theme.infoLabel("POSTGRES")} ${event.fileIndex}/${event.totalFiles} ${event.dataset} exported with ${formatCount(event.rows)} row(s).`
+      );
+      return;
+    }
+    if (event.kind === "finish") {
+      console.log(
+        theme.successLabel("POSTGRES"),
+        `Exported ${event.totalFiles} file(s) with ${formatCount(event.totalRows)} row(s).`
+      );
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Script path", event.scriptPath));
+    }
+  };
+}
+function createPostgresDirectScriptProgressReporter() {
+  return (event) => {
+    if (event.kind === "start") {
+      console.log(
+        theme.infoLabel("POSTGRES"),
+        "Starting direct PostgreSQL script generation..."
+      );
+      console.log(formatKeyValue("Input path", event.inputPath));
+      console.log(formatKeyValue("Validated path", event.validatedPath));
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Source encoding", event.sourceEncoding));
+      console.log(formatKeyValue("Files queued", event.totalFiles));
+      return;
+    }
+    if (event.kind === "file_registered") {
+      console.log(
+        `${theme.infoLabel("POSTGRES")} ${event.fileIndex}/${event.totalFiles} ${event.dataset} registered (${formatBytes(event.fileSize)}).`
+      );
+      return;
+    }
+    if (event.kind === "finish") {
+      console.log(
+        theme.successLabel("POSTGRES"),
+        `Generated direct import script for ${event.totalFiles} file(s) (${formatBytes(event.totalBytes)}).`
+      );
+      console.log(formatKeyValue("Output path", event.outputPath));
+      console.log(formatKeyValue("Script path", event.scriptPath));
+    }
+  };
+}
 
 // src/cli/ui/output/quarantine.ts
 function printAppliedFilters(summaryFilters) {
@@ -10164,8 +11184,116 @@ function registerQuarantineCommands(program) {
   });
 }
 
+// src/cli/commands/register-postgres.ts
+function registerPostgresCommands(program) {
+  const postgres = program.command("postgres").description(
+    "PostgreSQL-oriented helpers for hybrid loading and database operations."
+  );
+  postgres.command("generate-script").argument(
+    "<input>",
+    "Path to the sanitized dataset directory generated by cnpj-db-loader sanitize."
+  ).option(
+    "--output <path>",
+    "Custom output directory for the generated psql script and manifest."
+  ).option(
+    "--dataset <dataset>",
+    "Generate a script only for one dataset block, for example establishments or companies."
+  ).option(
+    "--script-name <name>",
+    "Generated psql script file name. Defaults to import-postgres-direct.sql."
+  ).option(
+    "--source-encoding <encoding>",
+    "PostgreSQL client encoding used while reading sanitized Receita files. Defaults to WIN1252."
+  ).option("-f, --force", "Skip the confirmation prompt.").description(
+    "Generate a direct psql import script that loads sanitized Receita files without rewriting them into new CSV files."
+  ).action(
+    async (input2, options) => {
+      if (!options.force) {
+        const confirmed = await confirm(
+          `Generate a direct PostgreSQL psql import script from ${input2}? This command does not rewrite the source files; it creates only a SQL script and manifest.`
+        );
+        if (!confirmed) {
+          console.log("PostgreSQL direct script generation cancelled.");
+          return;
+        }
+      }
+      const progress = createPostgresDirectScriptProgressReporter();
+      const generateOptions = {
+        onProgress: progress
+      };
+      if (options.output) {
+        generateOptions.outputPath = options.output;
+      }
+      if (options.dataset) {
+        generateOptions.dataset = options.dataset;
+      }
+      if (options.scriptName) {
+        generateOptions.scriptName = options.scriptName;
+      }
+      if (options.sourceEncoding) {
+        generateOptions.sourceEncoding = options.sourceEncoding;
+      }
+      const summary = await generatePostgresDirectScript(
+        input2,
+        generateOptions
+      );
+      const logFilePath = await writeCommandLog(
+        "postgres-generate-script",
+        summary
+      );
+      printPostgresDirectScriptSummary(summary, logFilePath);
+    }
+  );
+  postgres.command("export-csv").argument(
+    "<input>",
+    "Path to the sanitized or validated extracted dataset directory."
+  ).option(
+    "--output <path>",
+    "Custom output directory for PostgreSQL-ready CSV files."
+  ).option(
+    "--dataset <dataset>",
+    "Export only one dataset block, for example establishments or companies."
+  ).option(
+    "--script-name <name>",
+    "Generated psql script file name. Defaults to import-postgres-direct.sql."
+  ).option("-f, --force", "Skip the confirmation prompt.").description(
+    "Convert sanitized Receita files into real PostgreSQL-ready CSV files and generate a direct psql import script."
+  ).action(
+    async (input2, options) => {
+      if (!options.force) {
+        const confirmed = await confirm(
+          `Export PostgreSQL-ready CSV files from ${input2}? This command creates normalized CSV files and a generated psql import script.`
+        );
+        if (!confirmed) {
+          console.log("PostgreSQL CSV export cancelled.");
+          return;
+        }
+      }
+      const progress = createPostgresCsvExportProgressReporter();
+      const exportOptions = {
+        onProgress: progress
+      };
+      if (options.output) {
+        exportOptions.outputPath = options.output;
+      }
+      if (options.dataset) {
+        exportOptions.dataset = options.dataset;
+      }
+      if (options.scriptName) {
+        exportOptions.scriptName = options.scriptName;
+      }
+      const summary = await exportPostgresCsvDataset(input2, exportOptions);
+      const logFilePath = await writeCommandLog(
+        "postgres-export-csv",
+        summary
+      );
+      printPostgresCsvExportSummary(summary, logFilePath);
+    }
+  );
+}
+
 // src/cli/commands/register-schema.ts
-import path16 from "path";
+import path19 from "path";
 function ensureSqlExtension(fileName) {
   return fileName.toLowerCase().endsWith(".sql") ? fileName : `${fileName}.sql`;
 }
@@ -10183,7 +11311,7 @@ function resolveSchemaOutputPath(profile, name, output2) {
   const fileName = ensureSqlExtension(
     name?.trim() || getDefaultSchemaBaseName(profile)
   );
-  return path16.resolve(output2 ?? process.cwd(), fileName);
+  return path19.resolve(output2 ?? process.cwd(), fileName);
 }
 function registerSchemaCommands(program) {
   const schema = program.command("schema").description(
@@ -10270,12 +11398,25 @@ function registerValidateCommands(program) {
 }
 
 // src/cli/shared/app-config.ts
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { dirname as dirname2, resolve } from "path";
 import { fileURLToPath } from "url";
+function findPackageJsonPath() {
+  let currentDir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    const candidatePath = resolve(currentDir, "package.json");
+    if (existsSync(candidatePath)) {
+      return candidatePath;
+    }
+    currentDir = resolve(currentDir, "..");
+  }
+  return null;
+}
 function getPackageVersion() {
-  const currentDir = dirname2(fileURLToPath(import.meta.url));
-  const packageJsonPath = resolve(currentDir, "../package.json");
+  const packageJsonPath = findPackageJsonPath();
+  if (!packageJsonPath) {
+    return "0.0.0";
+  }
   const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
   return packageJson.version ?? "0.0.0";
 }
@@ -10302,9 +11443,14 @@ ${theme.section("Recommended flow")}
   ${theme.command("cnpj-db-loader database cleanup staging --force")}
   ${theme.command("cnpj-db-loader import ./downloads/<reference>/sanitized")}
 
+${theme.section("Hybrid PostgreSQL path")}
+  ${theme.command("cnpj-db-loader postgres generate-script ./downloads/<reference>/sanitized --output ./downloads/<reference>/postgres-direct --force")}
+  ${theme.command('psql "postgres://user:password@localhost:5432/cnpj" -f ./downloads/<reference>/postgres-direct/import-postgres-direct.sql')}
+
 ${theme.section("Notes")}
   ${theme.muted("Use federal-revenue when you want the CLI to check/download the remote monthly dataset first. Use inspect first when you already have local files.")}
   ${theme.muted("Generate the schema only when you need to create the database structure. Sanitization is the recommended preparation step before recurring imports.")}
+  ${theme.muted("Use postgres generate-script when you want PostgreSQL to run the heavy bulk load directly from sanitized Receita files through a generated psql script.")}
   ${theme.muted("JSON execution logs are written inside the user home directory at ~/.cnpjdbloader/logs with structured level/event metadata.")}
 `;
 }
@@ -10321,6 +11467,7 @@ function buildProgram() {
   registerSchemaCommands(program);
   registerFederalRevenueCommands(program);
   registerDatabaseCommands(program);
+  registerPostgresCommands(program);
   registerImportCommands(program);
   registerQuarantineCommands(program);
   registerDoctorCommands(program);