@newpeak/barista-cli 0.1.9 → 0.1.11

package/src/commands/liberica/transfer-in-forms/get.ts

@@ -0,0 +1,107 @@
+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';
+import { TransferInForm, TransferInFormItem } from '../../../types/transfer-in-form.js';
+
+export function createTransferInFormGetCommand(): Command {
+  const getCommand = new Command('get');
+  getCommand.description('Get transfer-in form details by ID');
+  getCommand.arguments('<transferInFormId>');
+  getCommand.option('--json', 'Output as JSON');
+
+  getCommand.action(async (transferInFormId: string, options: Record<string, unknown>) => {
+    const context = configManager.getCurrentContext();
+    const environment = (options.env as Environment) || context.environment;
+    const tenant = (options.tenant as string) || context.tenant;
+
+    if (!transferInFormId || transferInFormId.trim() === '') {
+      console.error(chalk.red('\n✗ Invalid transfer-in form ID.\n'));
+      process.exit(1);
+    }
+
+    try {
+      const response = await apiClient.getTransferInForm(environment, tenant, transferInFormId);
+
+      if (!response.success) {
+        const errorCode = response.error?.code || 'UNKNOWN_ERROR';
+        const errorMessage = response.error?.message || 'Unknown error';
+
+        // Handle "transfer-in form not found" case
+        if (errorCode === '01001xx001' || errorMessage.includes('不存在')) {
+          console.error(chalk.red(`\n✗ Transfer-in form not found: ${transferInFormId}\n`));
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${errorMessage} (${errorCode})\n`));
+        }
+        process.exit(1);
+      }
+
+      const transferInForm = response.data as TransferInForm | null;
+
+      if (!transferInForm) {
+        console.error(chalk.red('\n✗ Transfer-in form not found\n'));
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: true,
+          data: transferInForm,
+        }, null, 2));
+        return;
+      }
+
+      // Main details table
+      console.log(chalk.bold('\n📋 Transfer-In Form Details\n'));
+      console.log(`  ${chalk.gray('ID:')}            ${transferInForm.transferInFormId}`);
+      console.log(`  ${chalk.gray('Code:')}          ${transferInForm.transferInFormCode}`);
+      console.log(`  ${chalk.gray('Warehouse:')}     ${transferInForm.mainWarehouseCode}`);
+      console.log(`  ${chalk.gray('Stock Date:')}    ${transferInForm.stockDate}`);
+      console.log(`  ${chalk.gray('Type:')}          ${transferInForm.transferInType}`);
+      console.log(`  ${chalk.gray('Follower:')}      ${transferInForm.followerName || transferInForm.follower}`);
+      console.log(`  ${chalk.gray('Review Flag:')}   ${transferInForm.reviewFlag === 'REVIEWED' ? 'Reviewed' : 'Unreviewed'}`);
+      if (transferInForm.reviewer) {
+        console.log(`  ${chalk.gray('Reviewer:')}      ${transferInForm.reviewerName || transferInForm.reviewer}`);
+      }
+      if (transferInForm.reviewTime) {
+        console.log(`  ${chalk.gray('Review Time:')}  ${transferInForm.reviewTime}`);
+      }
+      if (transferInForm.remark) {
+        console.log(`  ${chalk.gray('Remark:')}       ${transferInForm.remark}`);
+      }
+      console.log();
+
+      // Item list table
+      const items = transferInForm.itemList || [];
+      if (items.length > 0) {
+        console.log(chalk.bold(`Items (${items.length}):\n`));
+        const itemTable = new Table({
+          head: [chalk.bold('Material Code'), chalk.bold('Material Name'), chalk.bold('Qty'), chalk.bold('UOM'), chalk.bold('Unit Price'), chalk.bold('Amount')],
+          colWidths: [15, 20, 10, 8, 12, 12],
+          style: { head: [], border: [] },
+        });
+
+        for (const item of items as TransferInFormItem[]) {
+          itemTable.push([
+            item.materialCode || '-',
+            item.materialName || '-',
+            String(item.stockQuantity !== undefined ? item.stockQuantity : item.formQuantity),
+            item.materialUomCode || '-',
+            item.unitPrice !== undefined ? String(item.unitPrice) : '-',
+            item.stockAmount !== undefined ? String(item.stockAmount) : '-',
+          ]);
+        }
+
+        console.log(itemTable.toString());
+        console.log();
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+      process.exit(1);
+    }
+  });
+
+  return getCommand;
+}

package/src/commands/liberica/transfer-in-forms/index.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { createTransferInFormListCommand } from './list.js';
+import { createTransferInFormGetCommand } from './get.js';
+import { createTransferInFormCreateCommand } from './create.js';
+import { createTransferInFormUpdateCommand } from './update.js';
+import { createTransferInFormBatchDeleteCommand } from './batch-delete.js';
+import { createTransferInFormBatchReviewCommand } from './batch-review.js';
+import { createTransferInFormBatchUnreviewCommand } from './batch-unreview.js';
+
+export function createTransferInFormsCommand(): Command {
+  const transferInFormsCommand = new Command('transfer-in-forms');
+  transferInFormsCommand.description('Manage transfer-in forms');
+
+  transferInFormsCommand.addCommand(createTransferInFormListCommand());
+  transferInFormsCommand.addCommand(createTransferInFormGetCommand());
+  transferInFormsCommand.addCommand(createTransferInFormCreateCommand());
+  transferInFormsCommand.addCommand(createTransferInFormUpdateCommand());
+  transferInFormsCommand.addCommand(createTransferInFormBatchDeleteCommand());
+  transferInFormsCommand.addCommand(createTransferInFormBatchReviewCommand());
+  transferInFormsCommand.addCommand(createTransferInFormBatchUnreviewCommand());
+
+  return transferInFormsCommand;
+}

package/src/commands/liberica/transfer-in-forms/list.ts

@@ -0,0 +1,97 @@
+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 { TransferInFormCompact, TransferInFormCompactListResponse } from '../../../types/transfer-in-form.js';
+import { Environment } from '../../../types/index.js';
+
+export function createTransferInFormListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List transfer-in forms with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--code <string>', 'Transfer-in form code')
+    .option('--warehouse-code <string>', 'Warehouse code')
+    .option('--type <string>', 'Transfer-in type')
+    .option('--review-flag <string>', 'Review flag (REVIEWED/UN_REVIEWED)')
+    .option('--stock-date <string>', 'Stock date (YYYY-MM-DD)')
+    .option('--stock-date-from <string>', 'Stock date from (YYYY-MM-DD)')
+    .option('--stock-date-to <string>', 'Stock date to (YYYY-MM-DD)')
+    .option('--material-code <string>', 'Material code')
+    .option('--material-name <string>', 'Material name')
+    .option('--follower <string>', 'Follower')
+    .option('--reviewer <string>', 'Reviewer')
+    .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; // API uses 0-based
+      const size = parseInt(options.size as string, 10);
+
+      const params: Record<string, unknown> = { pageNo: page, pageSize: size };
+      if (options.code) params.transferInFormCode = options.code;
+      if (options.warehouseCode) params.warehouseCode = options.warehouseCode;
+      if (options.type) params.transferInType = options.type;
+      if (options.reviewFlag) params.reviewFlag = options.reviewFlag;
+      if (options.stockDate) params.stockDate = options.stockDate;
+      if (options.stockDateFrom) params.stockDateBegin = options.stockDateFrom;
+      if (options.stockDateTo) params.stockDateEnd = options.stockDateTo;
+      if (options.materialCode) params.materialCode = options.materialCode;
+      if (options.materialName) params.materialName = options.materialName;
+      if (options.follower) params.follower = options.follower;
+      if (options.reviewer) params.reviewer = options.reviewer;
+
+      const response = await apiClient.listTransferInForms(environment, tenant, params as any);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list transfer-in forms: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      const data = response.data as TransferInFormCompactListResponse | undefined;
+      if (!data || data.totalRows === 0) {
+        console.log(chalk.bold('\n📋 Transfer-In Form List\n'));
+        console.log(chalk.gray('  No records found\n'));
+        return;
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data }, null, 2));
+        return;
+      }
+
+      const records = data.rows || [];
+      console.log(chalk.bold('\n📋 Transfer-In Form List\n'));
+
+      const table = new Table({
+        head: [chalk.bold('ID'), chalk.bold('Code'), chalk.bold('Warehouse'), chalk.bold('Material'), chalk.bold('Qty'), chalk.bold('Review'), chalk.bold('Date')],
+        colWidths: [20, 15, 12, 20, 10, 10, 12],
+        style: { head: [], border: [] },
+      });
+
+      for (const r of records as TransferInFormCompact[]) {
+        const quantity = r.stockQuantity !== undefined ? r.stockQuantity : r.formQuantity;
+        table.push([
+          r.transferInFormId || '-',
+          r.transferInFormCode || '-',
+          r.warehouseCode || '-',
+          r.materialName || '-',
+          String(quantity || ''),
+          r.reviewFlag === 'REVIEWED' ? chalk.green('Reviewed') : chalk.yellow('Unreviewed'),
+          r.stockDate || '-',
+        ]);
+      }
+
+      console.log(table.toString());
+      console.log();
+      console.log(chalk.gray(`  Total: ${data.totalRows} | Page: ${data.pageNo + 1} / ${Math.ceil(data.totalRows / data.pageSize) || 1}`));
+      console.log();
+    });
+
+  return listCommand;
+}

package/src/commands/liberica/transfer-in-forms/update.ts

@@ -0,0 +1,213 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { UpdateTransferInFormRequest, TransferInFormItemRequest } from '../../../types/transfer-in-form.js';
+import { Environment } from '../../../types/index.js';
+
+export function createTransferInFormUpdateCommand(): Command {
+  const cmd = new Command('update');
+  cmd.description('Update a transfer-in form');
+
+  cmd
+    .argument('<id>', 'Transfer-in form ID')
+    .option('-c, --code <code>', 'Transfer-in form code')
+    .option('-w, --warehouse-code <code>', 'Main warehouse code')
+    .option('-t, --type <type>', 'Transfer-in type')
+    .option('-f, --follower <id>', 'Follower ID')
+    .option('--follower-name <name>', 'Follower name')
+    .option('--stock-date <date>', 'Stock date (YYYY-MM-DD)')
+    .option('--remark <remark>', 'Remark')
+    // Individual item options (for single item update)
+    .option('--item-id <id>', 'Existing transfer-in form item ID (for updating existing item)')
+    .option('--item-warehouse-code <code>', 'Item warehouse code')
+    .option('-m, --material-code <code>', 'Material code')
+    .option('--material-no <no>', 'Material number')
+    .option('--material-name <name>', 'Material name')
+    .option('--material-type <type>', 'Material type')
+    .option('-q, --quantity <number>', 'Form quantity')
+    .option('--form-uom <code>', 'Form UOM code')
+    .option('--unit-price <price>', 'Unit price')
+    .option('--produced-date <date>', 'Produced date (YYYY-MM-DD)')
+    .option('--lot-no <no>', 'Lot number')
+    .option('--item-remark <remark>', 'Item remark')
+    // JSON items array (alternative to individual item options)
+    .option('--items <json>', 'JSON array of items (overrides individual item options)')
+    .option('--dry-run', 'Preview mode')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async (id, options) => {
+    const context = configManager.getCurrentContext();
+    const environment = context.environment as Environment;
+    const tenant = context.tenant;
+    const dryRun = options.dryRun === true;
+    const jsonOutput = options.json === true;
+
+    // Validate stock date format
+    if (options.stockDate && !/^\d{4}-\d{2}-\d{2}$/.test(options.stockDate)) {
+      console.error(chalk.red('\n✗ Invalid stock-date format. Use YYYY-MM-DD\n'));
+      process.exit(1);
+    }
+
+    const request: UpdateTransferInFormRequest = {
+      transferInFormId: id,
+    };
+
+    // Add optional fields if provided
+    if (options.code !== undefined) request.transferInFormCode = options.code;
+    if (options.warehouseCode !== undefined) request.mainWarehouseCode = options.warehouseCode;
+    if (options.stockDate !== undefined) request.stockDate = options.stockDate;
+    if (options.type !== undefined) request.transferInType = options.type;
+    if (options.follower !== undefined) request.follower = options.follower;
+    if (options.followerName !== undefined) request.followerName = options.followerName;
+    if (options.remark !== undefined) request.remark = options.remark;
+
+    let itemList: TransferInFormItemRequest[] | undefined = undefined;
+
+    if (options.items) {
+      // Parse JSON items
+      try {
+        const parsed = JSON.parse(options.items);
+        if (!Array.isArray(parsed)) {
+          console.error(chalk.red('\n✗ --items must be a JSON array\n'));
+          process.exit(1);
+        }
+        // Validate each item has required fields (if updating items, all required fields must be present)
+        for (const item of parsed) {
+          if (!item.warehouseCode || !item.materialCode || !item.formQuantity || !item.formMaterialUomCode || item.formUnitPrice == null) {
+            console.error(chalk.red('\n✗ Each item must have warehouseCode, materialCode, formQuantity, formMaterialUomCode, formUnitPrice\n'));
+            process.exit(1);
+          }
+        }
+        itemList = parsed;
+      } catch (error) {
+        console.error(chalk.red('\n✗ Invalid JSON for --items: ' + (error instanceof Error ? error.message : 'Unknown error') + '\n'));
+        process.exit(1);
+      }
+    } else {
+      // Check if any individual item option is provided
+      const hasItemOption = options.itemId !== undefined ||
+        options.itemWarehouseCode !== undefined ||
+        options.materialCode !== undefined ||
+        options.materialNo !== undefined ||
+        options.materialName !== undefined ||
+        options.materialType !== undefined ||
+        options.quantity !== undefined ||
+        options.formUom !== undefined ||
+        options.unitPrice !== undefined ||
+        options.producedDate !== undefined ||
+        options.lotNo !== undefined ||
+        options.itemRemark !== undefined;
+
+      if (hasItemOption) {
+        // Validate required fields for item update
+        if (!options.materialCode) {
+          console.error(chalk.red('\n✗ Material code is required when updating item (--material-code)\n'));
+          process.exit(1);
+        }
+        if (!options.formUom) {
+          console.error(chalk.red('\n✗ Form UOM code is required when updating item (--form-uom)\n'));
+          process.exit(1);
+        }
+        if (!options.unitPrice) {
+          console.error(chalk.red('\n✗ Unit price is required when updating item (--unit-price)\n'));
+          process.exit(1);
+        }
+
+        // Validate quantity
+        let quantity = 1;
+        if (options.quantity) {
+          const q = parseFloat(options.quantity);
+          if (isNaN(q) || q <= 0) {
+            console.error(chalk.red('\n✗ Quantity must be a positive number\n'));
+            process.exit(1);
+          }
+          quantity = q;
+        } else {
+          console.error(chalk.red('\n✗ Quantity is required when updating item (--quantity)\n'));
+          process.exit(1);
+        }
+
+        // Validate unit price
+        const unitPrice = parseFloat(options.unitPrice);
+        if (isNaN(unitPrice) || unitPrice < 0) {
+          console.error(chalk.red('\n✗ Unit price must be a non-negative number\n'));
+          process.exit(1);
+        }
+
+        // Validate produced date format
+        if (options.producedDate && !/^\d{4}-\d{2}-\d{2}$/.test(options.producedDate)) {
+          console.error(chalk.red('\n✗ Invalid produced-date format. Use YYYY-MM-DD\n'));
+          process.exit(1);
+        }
+
+        const item: TransferInFormItemRequest = {
+          transferInFormItemId: options.itemId,
+          warehouseCode: options.itemWarehouseCode || options.warehouseCode,
+          materialCode: options.materialCode,
+          materialNo: options.materialNo,
+          materialName: options.materialName,
+          materialType: options.materialType,
+          formQuantity: quantity,
+          formMaterialUomCode: options.formUom,
+          formUnitPrice: unitPrice,
+          producedDate: options.producedDate,
+          lotNo: options.lotNo,
+          remark: options.itemRemark,
+        };
+        itemList = [item];
+      }
+    }
+
+    if (itemList) {
+      request.itemList = itemList;
+    }
+
+    // Check if any fields to update (excluding transferInFormId)
+    const updateFields = Object.keys(request).filter(k => k !== 'transferInFormId');
+    if (updateFields.length === 0) {
+      console.error(chalk.red('\n✗ No fields to update. Provide at least one option to change.\n'));
+      process.exit(1);
+    }
+
+    if (dryRun) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, dryRun: true, data: request }));
+      } else {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode: No changes will be made\n'));
+        console.log('  Transfer-in form to be updated:');
+        console.log(`  ID: ${request.transferInFormId}`);
+        updateFields.forEach(field => {
+          const value = request[field as keyof UpdateTransferInFormRequest];
+          console.log(`  ${field}: ${Array.isArray(value) ? JSON.stringify(value) : value}`);
+        });
+        console.log();
+      }
+      return;
+    }
+
+    if (!jsonOutput) {
+      console.log(chalk.bold('\n📝 Updating Transfer-In Form\n'));
+    }
+
+    const response = await apiClient.updateTransferInForm(environment, tenant, request);
+
+    if (response.success) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, data: response.data }));
+      } else {
+        console.log(chalk.green('\n✓ Transfer-in form updated successfully\n'));
+      }
+    } else {
+      const errMsg = response.error?.message || 'Failed to update';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: response.error?.code, message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+  });
+
+  return cmd;
+}

package/src/commands/liberica/transfer-out-forms/batch-delete.ts

@@ -0,0 +1,83 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createTransferOutFormBatchDeleteCommand(): Command {
+  const cmd = new Command('batch-delete');
+  cmd
+    .description('Batch delete transfer-out forms')
+    .argument('<ids...>', 'Transfer-out form IDs to delete')
+    .option('--force', 'Skip confirmation and delete directly')
+    .option('--dry-run', 'Preview what would be deleted')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async (ids: string[], options: Record<string, unknown>) => {
+    const context = configManager.getCurrentContext();
+    const environment = context.environment as Environment;
+    const tenant = context.tenant;
+    const jsonOutput = options.json === true;
+    const dryRun = options.dryRun === true;
+    const force = options.force === true;
+
+    if (ids.length === 0) {
+      const errMsg = 'No transfer-out form IDs provided';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: 'MISSING_IDS', message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+
+    if (dryRun) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, dryRun: true, ids }));
+      } else {
+        console.log(chalk.bold(`\n🔍 Dry-Run Mode: No actual deletion will be made\n`));
+        console.log(chalk.gray(`  Form IDs: ${ids.join(', ')}`));
+        console.log(chalk.gray(`  Count: ${ids.length}\n`));
+      }
+      return;
+    }
+
+    if (!force) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, dryRun: true, ids }));
+      } else {
+        console.log(chalk.bold(`\n🗑️  Batch Delete Transfer-Out Forms (${environment})\n`));
+        console.log(chalk.gray(`  Form IDs: ${ids.join(', ')}`));
+        console.log(chalk.gray(`  Count: ${ids.length}\n`));
+        console.log(chalk.cyan('  To delete, add: --force\n'));
+      }
+      return;
+    }
+
+    if (!jsonOutput) {
+      console.log(chalk.bold(`\n🗑️  Batch Delete Transfer-Out Forms (${environment})\n`));
+      console.log(chalk.gray(`  Form IDs: ${ids.join(', ')}`));
+      console.log(chalk.gray(`  Count: ${ids.length}\n`));
+    }
+
+    const response = await apiClient.batchDeleteTransferOutForms(environment, tenant, ids);
+
+    if (response.success) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, ids, count: ids.length }));
+      } else {
+        console.log(chalk.green(`\n✓ ${ids.length} transfer-out form(s) deleted successfully\n`));
+      }
+    } else {
+      const errMsg = response.error?.message || 'Failed to delete';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: response.error?.code, message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+  });
+
+  return cmd;
+}

package/src/commands/liberica/transfer-out-forms/batch-review.ts

@@ -0,0 +1,148 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+import { TransferOutForm } from '../../../types/transfer-out-form.js';
+
+export function createTransferOutFormBatchReviewCommand(): Command {
+  const cmd = new Command('batch-review');
+  cmd
+    .description('Batch review (审核) transfer-out forms')
+    .argument('<ids...>', 'Transfer-out form IDs to review')
+    .option('--force', 'Skip confirmation and review directly')
+    .option('--dry-run', 'Preview what would be reviewed')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async (ids: string[], options: Record<string, unknown>) => {
+    const context = configManager.getCurrentContext();
+    const environment = context.environment as Environment;
+    const tenant = context.tenant;
+    const jsonOutput = options.json === true;
+    const dryRun = options.dryRun === true;
+    const force = options.force === true;
+
+    if (ids.length === 0) {
+      const errMsg = 'No transfer-out form IDs provided';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: 'MISSING_IDS', message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+
+    // Validate IDs are non-empty strings
+    const validIds = ids.filter(id => id.trim() !== '');
+    if (validIds.length === 0) {
+      const errMsg = 'No valid transfer-out form IDs provided';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: 'INVALID_IDS', message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+
+    // Fetch details for dry-run or confirmation
+    const forms: TransferOutForm[] = [];
+    if (!force || dryRun) {
+      for (const id of validIds) {
+        try {
+          const response = await apiClient.getTransferOutForm(environment, tenant, id);
+          if (response.success && response.data && 'transferOutFormId' in (response.data as any)) {
+            forms.push(response.data as TransferOutForm);
+          }
+        } catch {
+          // ignore fetch errors
+        }
+      }
+    }
+
+    if (dryRun) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({
+          success: true,
+          dryRun: true,
+          ids: validIds,
+          forms: forms.map(form => ({
+            transferOutFormId: form.transferOutFormId,
+            transferOutFormCode: form.transferOutFormCode,
+            warehouseCode: form.warehouseCode,
+            stockDate: form.stockDate,
+            reviewFlag: form.reviewFlag,
+          })),
+          message: 'Dry-run mode: no actual review will be performed',
+        }));
+      } else {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode: No changes will be made\n'));
+        console.log(chalk.gray(`  IDs to review: ${validIds.join(', ')}\n`));
+        if (forms.length > 0) {
+          console.log(chalk.gray('  Transfer-out forms to be reviewed:'));
+          forms.forEach(form => {
+            console.log(chalk.gray(`    • ${form.transferOutFormCode} (ID: ${form.transferOutFormId})`));
+          });
+          console.log();
+        }
+      }
+      return;
+    }
+
+    if (!force) {
+      if (!jsonOutput) {
+        console.log(chalk.bold('\n📝 Batch Review Transfer-Out Forms\n'));
+        console.log(chalk.gray(`  IDs: ${validIds.join(', ')}\n`));
+        if (forms.length > 0) {
+          console.log(chalk.gray('  Transfer-out forms to review:'));
+          forms.forEach(form => {
+            console.log(chalk.gray(`    • ${form.transferOutFormCode} (ID: ${form.transferOutFormId})`));
+          });
+          console.log();
+        }
+      }
+
+      const { confirm } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: `Review ${validIds.length} transfer-out form(s)?`,
+          default: false,
+        },
+      ]);
+
+      if (!confirm) {
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'CANCELLED', message: 'Operation cancelled by user' } }));
+        } else {
+          console.log(chalk.gray('\n  Operation cancelled.\n'));
+        }
+        process.exit(0);
+      }
+    }
+
+    if (!jsonOutput) {
+      console.log(chalk.bold(`\n📝 Reviewing ${validIds.length} Transfer-Out Form(s)\n`));
+    }
+
+    const response = await apiClient.batchReviewTransferOutForms(environment, tenant, validIds);
+
+    if (response.success) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, reviewedCount: validIds.length, ids: validIds }));
+      } else {
+        console.log(chalk.green(`\n✓ ${validIds.length} transfer-out form(s) reviewed\n`));
+      }
+    } else {
+      const errMsg = response.error?.message || 'Failed to review';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: response.error?.code, message: errMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ ${errMsg}\n`));
+      }
+      process.exit(1);
+    }
+  });
+
+  return cmd;
+}