@newpeak/barista-cli 0.1.6 → 0.1.8

package/src/commands/liberica/operations/index.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { createOperationsListCommand } from './list.js';
+import { createOperationGetCommand } from './get.js';
+import { createOperationCreateCommand } from './create.js';
+import { createOperationsUpdateCommand } from './update.js';
+import { createOperationsDeleteCommand } from './delete.js';
+import { createOperationsCopyCommand } from './copy.js';
+import { createBatchDeleteCommand } from './batch-delete.js';
+import { createOperationActiveCommand } from './active.js';
+import { createOperationDeactiveCommand } from './deactive.js';
+
+export function createOperationsCommand(): Command {
+  const operationsCommand = new Command('operations');
+  operationsCommand.description('Manage operations');
+
+  operationsCommand.addCommand(createOperationsListCommand());
+  operationsCommand.addCommand(createOperationGetCommand());
+  operationsCommand.addCommand(createOperationCreateCommand());
+  operationsCommand.addCommand(createOperationsUpdateCommand());
+  operationsCommand.addCommand(createOperationsDeleteCommand());
+  operationsCommand.addCommand(createOperationsCopyCommand());
+  operationsCommand.addCommand(createBatchDeleteCommand());
+  operationsCommand.addCommand(createOperationActiveCommand());
+  operationsCommand.addCommand(createOperationDeactiveCommand());
+
+  return operationsCommand;
+}

package/src/commands/liberica/operations/list.ts

@@ -0,0 +1,180 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { OperationListResponse, OperationType, StatusFlag } from '../../../types/operation.js';
+import { Environment } from '../../../types/index.js';
+
+const OPERATION_TYPE_MAP: Record<OperationType, string> = {
+  EQUIPMENT: '机器',
+  HUMAN: '手工',
+  PACKAGE: '包装',
+  QUALITY_TESTING: '质检',
+  OTHER: '其它',
+};
+
+const OPERATION_TYPE_REVERSE: Record<string, OperationType> = {
+  EQUIPMENT: 'EQUIPMENT',
+  equipment: 'EQUIPMENT',
+  '机器': 'EQUIPMENT',
+  HUMAN: 'HUMAN',
+  human: 'HUMAN',
+  '手工': 'HUMAN',
+  PACKAGE: 'PACKAGE',
+  package: 'PACKAGE',
+  '包装': 'PACKAGE',
+  QUALITY_TESTING: 'QUALITY_TESTING',
+  quality_testing: 'QUALITY_TESTING',
+  qualitytesting: 'QUALITY_TESTING',
+  '质检': 'QUALITY_TESTING',
+  OTHER: 'OTHER',
+  other: 'OTHER',
+  '其它': 'OTHER',
+  '其他': 'OTHER',
+};
+
+function normalizeOperationType(input: string | undefined): OperationType | undefined {
+  if (!input) return undefined;
+  const normalized = input.trim().toUpperCase();
+  return OPERATION_TYPE_REVERSE[normalized] || OPERATION_TYPE_REVERSE[input];
+}
+
+function getOperationTypeDisplay(type: OperationType): string {
+  return OPERATION_TYPE_MAP[type] || type;
+}
+
+export function createOperationsListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List operations with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--status <number>', 'Status filter (1=enable, 2=disable)')
+    .option('--keyword <string>', 'Filter by operation name or code (partial match)')
+    .option('--type <string>', 'Filter by operation type (EQUIPMENT/HUMAN/PACKAGE/QUALITY_TESTING/OTHER or Chinese: 机器/手工/包装/质检/其它)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const page = parseInt(options.page as string, 10) - 1;
+      const size = parseInt(options.size as string, 10);
+
+      const params: {
+        pageNo: number;
+        pageSize: number;
+        status?: StatusFlag;
+        operationCode?: string;
+        operationName?: string;
+        operationType?: OperationType;
+      } = { pageNo: page, pageSize: size };
+
+      if (options.status !== undefined) {
+        const statusNum = parseInt(options.status as string, 10);
+        if (statusNum === 1 || statusNum === 2) {
+          params.status = statusNum as StatusFlag;
+        }
+      }
+
+      if (options.keyword !== undefined) {
+        params.operationCode = options.keyword as string;
+        params.operationName = options.keyword as string;
+      }
+
+      if (options.type !== undefined) {
+        const normalizedType = normalizeOperationType(options.type as string);
+        if (normalizedType) {
+          params.operationType = normalizedType;
+        }
+      }
+
+      const response = await apiClient.listOperations(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list operations: ${response.error?.message || 'Unknown error'}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+        process.exit(1);
+      }
+
+      const data = response.data as OperationListResponse | null;
+
+      if (!data) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: { items: [], pagination: { pageNo: 0, pageSize: 20, totalRows: 0 } } }, null, 2));
+        } else {
+          console.log(chalk.bold('\n📋 Operation List\n'));
+          console.log(chalk.gray('  No operations found\n'));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: {
+                items: data.rows || [],
+                pagination: {
+                  pageNo: data.pageNo,
+                  pageSize: data.pageSize,
+                  totalRows: data.totalRows,
+                },
+              },
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+
+      const records = data.rows || [];
+
+      if (records.length === 0) {
+        console.log(chalk.bold('\n📋 Operation List\n'));
+        console.log(chalk.gray('  No operations found\n'));
+        return;
+      }
+
+      console.log(chalk.bold('\n📋 Operation List\n'));
+
+      const table = new Table({
+        head: [chalk.bold('ID'), chalk.bold('Code'), chalk.bold('Name'), chalk.bold('Type'), chalk.bold('Work Center'), chalk.bold('Status')],
+        colWidths: [12, 14, 22, 12, 18, 10],
+        style: {
+          head: [],
+          border: [],
+        },
+      });
+
+      for (const op of records) {
+        const statusText = op.statusFlag === 1 ? chalk.green('Enable') : chalk.red('Disable');
+        table.push([
+          op.operationId,
+          op.operationCode || '-',
+          op.operationName || '-',
+          getOperationTypeDisplay(op.operationType),
+          op.workCenterCode || '-',
+          statusText,
+        ]);
+      }
+
+      console.log(table.toString());
+      console.log();
+      console.log(
+        chalk.gray(
+          `  Total: ${data.totalRows} | Page: ${data.pageNo + 1} / ${Math.ceil(data.totalRows / data.pageSize) || 1} | Size: ${data.pageSize}`
+        )
+      );
+      console.log();
+    });
+
+  return listCommand;
+}

package/src/commands/liberica/operations/update.ts

@@ -0,0 +1,218 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Operation, OperationUpdateRequest, StatusFlag } from '../../../types/operation.js';
+import { Environment } from '../../../types/index.js';
+
+// Dictionary mapping for operation type display
+const OPERATION_TYPE_MAP: Record<string, string> = {
+  EQUIPMENT: '机器',
+  HUMAN: '手工',
+  PACKAGE: '包装',
+  QUALITY_TESTING: '质检',
+  OTHER: '其它',
+};
+
+// Reverse mapping for parsing CLI input
+const OPERATION_TYPE_REVERSE: Record<string, string> = {
+  EQUIPMENT: 'EQUIPMENT',
+  equipment: 'EQUIPMENT',
+  '机器': 'EQUIPMENT',
+  HUMAN: 'HUMAN',
+  human: 'HUMAN',
+  '手工': 'HUMAN',
+  PACKAGE: 'PACKAGE',
+  package: 'PACKAGE',
+  '包装': 'PACKAGE',
+  QUALITY_TESTING: 'QUALITY_TESTING',
+  quality_testing: 'QUALITY_TESTING',
+  qualitytesting: 'QUALITY_TESTING',
+  '质检': 'QUALITY_TESTING',
+  OTHER: 'OTHER',
+  other: 'OTHER',
+  '其它': 'OTHER',
+  '其他': 'OTHER',
+};
+
+function normalizeOperationType(input: string | undefined): string | undefined {
+  if (!input) return undefined;
+  const normalized = input.trim().toUpperCase();
+  return OPERATION_TYPE_REVERSE[normalized] || OPERATION_TYPE_REVERSE[input];
+}
+
+function getOperationTypeDisplay(type: string): string {
+  return OPERATION_TYPE_MAP[type] || type;
+}
+
+export function createOperationsUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand
+    .description('Update operation information')
+    .option('--id <id>', 'Operation ID')
+    .option('-n, --name <name>', 'Operation name')
+    .option('-t, --type <type>', 'Operation type (EQUIPMENT/HUMAN/PACKAGE/QUALITY_TESTING/OTHER or Chinese: 机器/手工/包装/质检/其它)')
+    .option('-w, --work-center <workCenter>', 'Work center code')
+    .option('--mould-code <mouldCode>', 'Mould code')
+    .option('--mould-type <mouldType>', 'Mould type')
+    .option('--equipment-type <equipmentType>', 'Equipment type')
+    .option('--lead-time <leadTime>', 'Lead time (hours)', (val) => parseInt(val, 10))
+    .option('--remark <remark>', 'Remarks')
+    .option('--status <status>', 'Status (1=enable, 2=disable)', (val) => parseInt(val, 10))
+    .option('--dry-run', 'Preview changes without making API call')
+    .option('--json', 'Output result as JSON')
+    .action(async (options: Record<string, unknown>) => {
+      const operationId = options.id as string | undefined;
+      if (!operationId) {
+        console.error(chalk.red('\n✗ --id is required\n'));
+        process.exit(1);
+      }
+      const operationIdStr: string = operationId;
+      const context = configManager.getCurrentContext();
+      const environment: Environment = (options.env as Environment) || context.environment;
+      const tenant: string = (options.tenant as string) || context.tenant;
+
+      const fields: Partial<OperationUpdateRequest> = {};
+      if (options.name) fields.operationName = options.name as string;
+      if (options.type) {
+        const normalizedType = normalizeOperationType(options.type as string);
+        if (normalizedType) {
+          fields.operationType = normalizedType as 'EQUIPMENT' | 'HUMAN' | 'PACKAGE' | 'QUALITY_TESTING' | 'OTHER';
+        }
+      }
+      if (options.workCenter) fields.workCenterCode = options.workCenter as string;
+      if (options.mouldCode) fields.mouldCode = options.mouldCode as string;
+      if (options.mouldType) fields.mouldType = options.mouldType as string;
+      if (options.equipmentType) fields.equipmentType = options.equipmentType as string;
+      if (options.leadTime) fields.leadTime = options.leadTime as number;
+      if (options.remark) fields.remark = options.remark as string;
+      if (options.status) {
+        const statusVal = options.status as number;
+        if (statusVal === 1 || statusVal === 2) {
+          fields.statusFlag = statusVal as StatusFlag;
+        }
+      }
+
+      const providedFields = Object.keys(fields).filter(
+        (k) => fields[k as keyof OperationUpdateRequest] !== undefined
+      );
+
+      if (providedFields.length === 0) {
+        console.error(
+          chalk.red('\n✗ No fields to update. Provide at least one of: --name, --type, --work-center, --mould-code, --mould-type, --equipment-type, --lead-time, --remark, --status\n')
+        );
+        process.exit(1);
+      }
+
+      // Validate lead time
+      if (options.leadTime && (isNaN(options.leadTime as number) || (options.leadTime as number) < 0)) {
+        console.error(chalk.red('\n✗ Invalid lead time. Must be a non-negative number\n'));
+        process.exit(1);
+      }
+
+      // Validate status
+      if (options.status) {
+        const statusVal = options.status as number;
+        if (statusVal !== 1 && statusVal !== 2) {
+          console.error(chalk.red('\n✗ Invalid status. Use 1 (enable) or 2 (disable)\n'));
+          process.exit(1);
+        }
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.bold(`\n📋 Update Operation — Dry Run (${environment})\n`));
+        console.log(chalk.gray(`  Operation ID: ${operationId}`));
+        console.log(chalk.gray('\n  Changes to be applied:'));
+        for (const field of providedFields) {
+          const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+          if (field === 'operationType') {
+            const displayType = getOperationTypeDisplay(fields[field as keyof OperationUpdateRequest] as string);
+            console.log(chalk.cyan(`    ${label}: "${displayType}"`));
+          } else {
+            console.log(chalk.cyan(`    ${label}: "${fields[field as keyof OperationUpdateRequest]}"`));
+          }
+        }
+        console.log();
+        return;
+      }
+
+      let currentOperation: Operation | undefined;
+      try {
+        const operationResponse = await apiClient.getOperationDetail(environment, tenant, operationIdStr);
+        if (!operationResponse.success || !operationResponse.data || Array.isArray(operationResponse.data)) {
+          console.error(chalk.red(`\n✗ Operation not found: ${operationIdStr}`));
+          if (operationResponse.error?.message) {
+            console.error(chalk.gray(`  ${operationResponse.error.message}`));
+          }
+          if (operationResponse.error?.code) {
+            console.error(chalk.gray(`  Error code: ${operationResponse.error.code}`));
+          }
+          console.error();
+          process.exit(1);
+        }
+        currentOperation = operationResponse.data as Operation;
+      } catch (error) {
+        console.error(chalk.red(`\n✗ Failed to fetch operation: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.bold(`\n📋 Update Operation (${environment})\n`));
+      console.log(chalk.gray(`  Operation ID: ${operationId}`));
+      console.log(chalk.gray(`  Current Name: ${currentOperation.operationName}`));
+      console.log(chalk.gray('\n  Changes:'));
+      for (const field of providedFields) {
+        const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+        let currentVal = (currentOperation as unknown as Record<string, unknown>)[field] ?? '(not set)';
+        let newVal = fields[field as keyof OperationUpdateRequest];
+
+        if (field === 'operationType') {
+          currentVal = getOperationTypeDisplay(currentVal as string);
+          newVal = getOperationTypeDisplay(newVal as string) as typeof newVal;
+        }
+        if (field === 'statusFlag') {
+          currentVal = currentVal === 1 ? 'Enable' : 'Disable';
+          newVal = newVal === 1 ? 'Enable' : 'Disable';
+        }
+
+        console.log(chalk.cyan(`    ${label}: "${currentVal}" → "${newVal}"`));
+      }
+
+      const updateData: OperationUpdateRequest = { operationId: operationIdStr, ...fields };
+      try {
+        const response = await apiClient.updateOperation(environment, tenant, updateData);
+
+        if (response.success) {
+          if (options.json) {
+            console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+          } else {
+            console.log(chalk.green('\n✓ Operation updated successfully\n'));
+          }
+        } else {
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: response.error }, null, 2));
+          } else {
+            console.error(chalk.red(`\n✗ Update failed: ${response.error?.message || 'Unknown error'}`));
+            if (response.error?.code) {
+              console.error(chalk.gray(`  Error code: ${response.error.code}`));
+            }
+            console.error();
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { message: error instanceof Error ? error.message : 'Unknown error' },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        }
+        process.exit(1);
+      }
+    });
+
+  return updateCommand;
+}

package/src/commands/liberica/orgs/index.ts

@@ -1,6 +1,5 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import Table from 'cli-table3';
 import { configManager } from '../../../core/config/manager.js';
 import { apiClient } from '../../../core/api/client.js';
 import { Environment } from '../../../types/index.js';

package/src/commands/liberica/stock/index.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+import { createStockListCommand } from './list.js';
+import { createStockLedgerCommand } from './ledger.js';
+
+export function createStockCommand(): Command {
+  const stockCommand = new Command('stock');
+  stockCommand.description('Manage stock inventory and ledger');
+
+  stockCommand.addCommand(createStockListCommand());
+  stockCommand.addCommand(createStockLedgerCommand());
+
+  return stockCommand;
+}

package/src/commands/liberica/stock/ledger.ts

@@ -0,0 +1,159 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { StockJourneyQueryParams, StockJourneyApiResponse, StockJourneySummaryApiResponse } from '../../../types/stock.js';
+import { Environment } from '../../../types/index.js';
+
+export function createStockLedgerCommand(): Command {
+  const ledgerCommand = new Command('ledger');
+  ledgerCommand.description('Query stock ledger/journey (inbound/outbound history)');
+
+  ledgerCommand
+    .option('--stock-id <string>', 'Stock/Journey ID')
+    .option('--stock-form-code <string>', 'Stock form document code')
+    .option('--stock-type <string>', 'Stock type (e.g. PURCHASE_STOCK_IN)')
+    .option('--stock-flag <INBOUND|OUTBOUND>', 'Stock flag (INBOUND or OUTBOUND)')
+    .option('--warehouse-code <string>', 'Warehouse code')
+    .option('--material-code <string>', 'Material code')
+    .option('--material-no <string>', 'Material number')
+    .option('--material-name <string>', 'Material name')
+    .option('--material-type <string>', 'Material type/spec')
+    .option('--color <string>', 'Color')
+    .option('--lot-no <string>', 'Lot/Batch number')
+    .option('--lot-code <string>', 'System lot code')
+    .option('--source-type <string>', 'Source document type')
+    .option('--source-code <string>', 'Source document code')
+    .option('--start-date <YYYY-MM-DD>', 'Stock date range start')
+    .option('--end-date <YYYY-MM-DD>', 'Stock date range end')
+    .option('--posting-month <YYYY-MM>', 'Posting month (e.g. 2026-01)')
+    .option('--summary', 'Show only summary (no detail list)')
+    .option('-p, --page <number>', 'Page number (1-based)', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = (options.tenant as string) || context.tenant;
+
+      if (!tenant) {
+        console.error(chalk.red('\n✗ No tenant configured. Run "barista liberica auth login" first.\n'));
+        process.exit(1);
+      }
+
+      const pageNo = parseInt(options.page as string, 10) - 1;
+      const pageSize = parseInt(options.size as string, 10);
+
+      const params: StockJourneyQueryParams = {
+        pageNo,
+        pageSize,
+      };
+
+      if (options.stockId) params.stockId = options.stockId;
+      if (options.stockFormCode) params.stockFormCode = options.stockFormCode;
+      if (options.stockType) params.stockType = options.stockType;
+      if (options.stockFlag) params.stockFlag = options.stockFlag;
+      if (options.warehouseCode) params.warehouseCode = options.warehouseCode;
+      if (options.materialCode) params.materialCode = options.materialCode;
+      if (options.materialNo) params.materialNo = options.materialNo;
+      if (options.materialName) params.materialName = options.materialName;
+      if (options.materialType) params.materialType = options.materialType;
+      if (options.color) params.color = options.color;
+      if (options.lotNo) params.lotNo = options.lotNo;
+      if (options.lotCode) params.lotCode = options.lotCode;
+      if (options.sourceType) params.sourceType = options.sourceType;
+      if (options.sourceCode) params.sourceCode = options.sourceCode;
+      if (options.startDate) params.startDate = options.startDate;
+      if (options.endDate) params.endDate = options.endDate;
+      if (options.postingMonth) params.postingMonth = options.postingMonth;
+
+      const showOnlySummary = options.summary === true;
+
+      const summaryResponse: StockJourneySummaryApiResponse = await apiClient.getStockLedgerSummary(environment, tenant, params);
+
+      if (!summaryResponse.success) {
+        console.error(chalk.red(`\n✗ Failed to get summary: ${summaryResponse.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const summary = summaryResponse.data;
+
+      if (options.json) {
+        if (showOnlySummary) {
+          console.log(JSON.stringify({ success: true, summary }, null, 2));
+          return;
+        }
+        const listResponse: StockJourneyApiResponse = await apiClient.listStockLedger(environment, tenant, params);
+        if (!listResponse.success) {
+          console.error(chalk.red(`\n✗ Failed: ${listResponse.error?.message}\n`));
+          process.exit(1);
+        }
+        console.log(JSON.stringify({ success: true, summary, data: listResponse.data }, null, 2));
+        return;
+      }
+
+      console.log(chalk.bold('\n  Stock Ledger Summary\n'));
+      if (summary) {
+        console.log(`  ${chalk.gray('Total Inbound:')}  ${chalk.green(summary.totalInboundCount?.toLocaleString() || 0)} units  ${chalk.green('¥' + (summary.totalInboundAmount || 0).toLocaleString())}`);
+        console.log(`  ${chalk.gray('Total Outbound:')} ${chalk.red(summary.totalOutboundCount?.toLocaleString() || 0)} units  ${chalk.red('¥' + (summary.totalOutboundAmount || 0).toLocaleString())}`);
+      }
+      console.log();
+
+      if (showOnlySummary) {
+        return;
+      }
+
+      const listResponse: StockJourneyApiResponse = await apiClient.listStockLedger(environment, tenant, params);
+      if (!listResponse.success) {
+        console.error(chalk.red(`\n✗ Failed: ${listResponse.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const data = listResponse.data!;
+      const items = data.rows || [];
+
+      if (items.length === 0) {
+        console.log(chalk.yellow('  No ledger records found.\n'));
+        return;
+      }
+
+      const table = new Table({
+        head: [
+          chalk.bold('Date'),
+          chalk.bold('Flag'),
+          chalk.bold('Warehouse'),
+          chalk.bold('Material'),
+          chalk.bold('Lot No'),
+          chalk.bold('In Qty'),
+          chalk.bold('Out Qty'),
+          chalk.bold('Doc No'),
+        ],
+        colWidths: [12, 8, 10, 16, 12, 8, 8, 16],
+        style: { border: [], head: [] },
+      });
+
+      for (const item of items) {
+        const flagColor = item.stockFlag === 'INBOUND' ? chalk.green : chalk.red;
+        table.push([
+          item.stockDate || '-',
+          flagColor(item.stockFlag || '-'),
+          item.warehouseCode || '-',
+          item.materialCode || '-',
+          item.lotNo || '-',
+          item.inboundCount != null ? item.inboundCount.toLocaleString() : '-',
+          item.outboundCount != null ? item.outboundCount.toLocaleString() : '-',
+          item.stockFormCode || '-',
+        ]);
+      }
+
+      console.log(chalk.bold('  Stock Ledger Detail\n'));
+      console.log(table.toString());
+
+      const totalPages = Math.ceil(data.totalRows / pageSize);
+      const currentPage = pageNo + 1;
+      console.log(chalk.gray(`\n  Page ${currentPage} of ${totalPages} (Total: ${data.totalRows.toLocaleString()})\n`));
+    });
+
+  return ledgerCommand;
+}