@newpeak/barista-cli 0.1.7 → 0.1.9

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

@@ -0,0 +1,157 @@
+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 { MouldEntityListResponse, MouldStatus } from '../../../types/mould.js';
+
+const VALID_STATUSES = ['FINE', 'REPAIR', 'SCRAP'] as const;
+
+export function createMouldListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List mould entities with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--status <status>', `Mould status filter (${VALID_STATUSES.join('|')})`)
+    .option('--material-code <code>', 'Material code filter')
+    .option('--material-name <name>', 'Material name filter (fuzzy)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const tenant = context.tenant;
+      const environment = context.environment;
+
+      const page = parseInt(options.page as string, 10);
+      const size = parseInt(options.size as string, 10);
+
+      const params: {
+        pageNo: number;
+        pageSize: number;
+        mouldStatus?: MouldStatus;
+        materialCode?: string;
+        materialName?: string;
+      } = { pageNo: page, pageSize: size };
+
+      if (options.status !== undefined) {
+        const status = options.status as MouldStatus;
+        if (VALID_STATUSES.includes(status)) {
+          params.mouldStatus = status;
+        }
+      }
+
+      if (options.materialCode !== undefined) {
+        params.materialCode = options.materialCode as string;
+      }
+
+      if (options.materialName !== undefined) {
+        params.materialName = options.materialName as string;
+      }
+
+      const response = await apiClient.listMouldEntities(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list moulds: ${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 MouldEntityListResponse | null;
+
+      if (!data) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { success: true, data: { rows: [], pagination: { pageNo: 0, pageSize: 20, totalRows: 0 } } },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(chalk.bold('\n📋 Mould List\n'));
+          console.log(chalk.gray('  No moulds found\n'));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: {
+                rows: 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📋 Mould List\n'));
+        console.log(chalk.gray('  No moulds found\n'));
+        return;
+      }
+
+      console.log(chalk.bold('\n📋 Mould List\n'));
+
+      const table = new Table({
+        head: [
+          chalk.bold('Code'),
+          chalk.bold('Material'),
+          chalk.bold('Type'),
+          chalk.bold('Status'),
+          chalk.bold('Warehouse'),
+          chalk.bold('Produced'),
+        ],
+        colWidths: [16, 20, 14, 10, 14, 12],
+        style: {
+          head: [],
+          border: [],
+        },
+      });
+
+      for (const mould of records) {
+        const statusText =
+          mould.mouldStatus === 'FINE'
+            ? chalk.green('FINE')
+            : mould.mouldStatus === 'REPAIR'
+              ? chalk.yellow('REPAIR')
+              : chalk.red('SCRAP');
+
+        table.push([
+          mould.mouldEntityCode || '-',
+          mould.materialName || '-',
+          mould.mouldType || '-',
+          statusText,
+          mould.currentWarehouseCode || '-',
+          mould.producedDate || '-',
+        ]);
+      }
+
+      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/mould/set-status.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { MouldStatus, MouldEntitySetStatusRequest } from '../../../types/mould.js';
+
+const VALID_STATUSES: MouldStatus[] = ['FINE', 'REPAIR', 'SCRAP'];
+
+export function createMouldSetStatusCommand(): Command {
+  const cmd = new Command('set-status');
+  cmd.description('Set mould status (FINE | REPAIR | SCRAP)');
+
+  cmd
+    .argument('<mouldEntityId>', 'Mould entity ID')
+    .argument('<status>', 'New status (FINE, REPAIR, or SCRAP)')
+    .option('--remark <remark>', 'Remark for status change')
+    .option('--json', 'Output as JSON')
+    .action(async (mouldEntityId: string, status: string, options: { remark?: string; json?: boolean }) => {
+      const context = configManager.getCurrentContext();
+      const tenant = context.tenant;
+      const environment = context.environment;
+
+      const mouldStatus = status.toUpperCase() as MouldStatus;
+      if (!VALID_STATUSES.includes(mouldStatus)) {
+        const errMsg = `Invalid status value: ${status}. Must be one of: ${VALID_STATUSES.join(', ')}`;
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { code: 'INVALID_STATUS', message: errMsg },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      const request: MouldEntitySetStatusRequest = {
+        mouldEntityId,
+        mouldStatus,
+        remark: options.remark,
+      };
+
+      if (!options.json) {
+        console.log(chalk.bold('\n🔧 Set Mould Status\n'));
+        console.log(`  ${chalk.gray('Mould ID:')}   ${mouldEntityId}`);
+        console.log(`  ${chalk.gray('New Status:')} ${mouldStatus}`);
+        if (options.remark) {
+          console.log(`  ${chalk.gray('Remark:')}    ${options.remark}`);
+        }
+        console.log();
+      }
+
+      const response = await apiClient.setMouldStatus(environment, tenant, request);
+
+      if (!response.success) {
+        const errorMsg = response.error?.message || 'Failed to set mould status';
+        const errorCode = response.error?.code || 'SET_MOULD_STATUS_ERROR';
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { code: errorCode, message: errorMsg },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ Failed to set mould status: ${errorMsg}`));
+          if (response.error?.code) {
+            console.error(chalk.gray(`  Error code: ${response.error.code}`));
+          }
+          console.error();
+        }
+        process.exit(1);
+      }
+
+      const data = response.data as { mouldEntityId?: string; mouldEntityCode?: string; mouldName?: string; mouldStatus?: string } | undefined;
+
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            success: true,
+            data: {
+              mouldId: data?.mouldEntityId || mouldEntityId,
+              mouldName: data?.mouldName,
+              currentStatus: data?.mouldStatus || mouldStatus,
+              remark: options.remark,
+            },
+          })
+        );
+      } else {
+        console.log(chalk.green(`✓ Mould status set to ${mouldStatus}`));
+        console.log();
+      }
+    });
+
+  return cmd;
+}

package/src/commands/liberica/mould/stock-in.ts

@@ -0,0 +1,165 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { apiClient } from '../../../core/api/client.js';
+import { configManager } from '../../../core/config/manager.js';
+import { MouldEntityRegFormRequest } from '../../../types/mould-stock-in.js';
+
+function formatTable(data: MouldEntityRegFormRequest): string {
+  const lines: string[] = [];
+  lines.push(`  ${chalk.gray('Form Code:')} ${data.mouldEntityRegFormCode || '(auto)'}`);
+  lines.push(`  ${chalk.gray('Stock Date:')} ${data.stockDate || '(today)'}`);
+  lines.push(`  ${chalk.gray('Warehouse:')} ${data.mainWarehouseCode}`);
+  lines.push(`  ${chalk.gray('Follower:')} ${data.follower}${data.followerName ? ` (${data.followerName})` : ''}`);
+  if (data.remark) lines.push(`  ${chalk.gray('Remark:')} ${data.remark}`);
+
+  const item = data.itemList[0];
+  if (item) {
+    lines.push('');
+    lines.push(`  ${chalk.gray('Material:')} ${item.materialCode}`);
+    if (item.materialName) lines.push(`  ${chalk.gray('Material Name:')} ${item.materialName}`);
+    if (item.materialNo) lines.push(`  ${chalk.gray('Material No:')} ${item.materialNo}`);
+    if (item.materialType) lines.push(`  ${chalk.gray('Material Type:')} ${item.materialType}`);
+    lines.push(`  ${chalk.gray('Quantity:')} ${item.formQuantity}`);
+    if (item.formMaterialUomCode) lines.push(`  ${chalk.gray('Form UOM:')} ${item.formMaterialUomCode}`);
+    if (item.producedDate) lines.push(`  ${chalk.gray('Produced Date:')} ${item.producedDate}`);
+    if (item.mouldType) lines.push(`  ${chalk.gray('Mould Type:')} ${item.mouldType}`);
+  }
+
+  return lines.join('\n');
+}
+
+export function createMouldStockInCommand(): Command {
+  const cmd = new Command('stock-in');
+  cmd.description('Create a mould stock-in (入库单) to add mould materials to the entity list');
+
+  cmd
+    .requiredOption('-m, --material-code <code>', 'Material code (required)')
+    .requiredOption('-w, --warehouse-code <code>', 'Main warehouse code (required)')
+    .requiredOption('-f, --follower <id>', 'Follower (入库人员) ID (required)')
+    .option('--follower-name <name>', 'Follower name')
+    .option('-q, --quantity <number>', 'Form quantity (default: 1)', (val) => {
+      const n = parseInt(val, 10);
+      if (isNaN(n) || n <= 0) {
+        console.error(chalk.red('\n✗ Error: --quantity must be a positive integer\n'));
+        process.exit(1);
+      }
+      return n;
+    })
+    .option('--form-uom <code>', 'Form unit of measure code (required)')
+    .option('--material-no <no>', 'Material number')
+    .option('--material-name <name>', 'Material name')
+    .option('--material-type <type>', 'Material type')
+    .option('--produced-date <date>', 'Produced date (ISO format YYYY-MM-DD)')
+    .option('--mould-type <type>', 'Mould type')
+    .option('--remark <remark>', 'Remark / 备注')
+    .option('--stock-date <date>', 'Stock-in date (default: today YYYY-MM-DD)')
+    .option('--dry-run', 'Preview mode, do not call API')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async () => {
+    const context = configManager.getCurrentContext();
+    const opts = cmd.opts();
+
+    const materialCode = opts.materialCode as string;
+    const warehouseCode = opts.warehouseCode as string;
+    const follower = opts.follower as string;
+    const followerName = opts.followerName as string | undefined;
+    const quantity = opts.quantity as number | undefined;
+    const formUom = opts.formUom as string | undefined;
+    const materialNo = opts.materialNo as string | undefined;
+    const materialName = opts.materialName as string | undefined;
+    const materialType = opts.materialType as string | undefined;
+    const producedDate = opts.producedDate as string | undefined;
+    const mouldType = opts.mouldType as string | undefined;
+    const remark = opts.remark as string | undefined;
+    const stockDate = opts.stockDate as string | undefined;
+    const dryRun = opts.dryRun === true;
+    const jsonOutput = opts.json === true;
+
+    const request: MouldEntityRegFormRequest = {
+      mouldEntityRegFormCode: '',
+      stockDate: stockDate || new Date().toISOString().split('T')[0],
+      mainWarehouseCode: warehouseCode,
+      follower,
+      followerName,
+      remark,
+      itemList: [
+        {
+          materialCode,
+          materialNo,
+          materialName,
+          materialType,
+          formQuantity: quantity || 1,
+          formMaterialUomCode: formUom,
+          producedDate,
+          mouldType,
+          warehouseCode,
+        },
+      ],
+    };
+
+    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('  Mould stock-in to be created:');
+        console.log(formatTable(request));
+        console.log();
+      }
+      return;
+    }
+
+    if (!jsonOutput) {
+      console.log(chalk.bold('\n📥 Creating Mould Stock-In\n'));
+    }
+
+    const response = await apiClient.createMouldStockIn(context.environment, context.tenant, request);
+
+    if (!response.success) {
+      const errorMsg = response.error?.message || 'Failed to create stock-in';
+      const errorCode = response.error?.code || 'CREATE_MOULD_STOCK_IN_ERROR';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ Failed to create stock-in: ${errorMsg}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+      }
+      process.exit(1);
+    }
+
+    if (response.success) {
+      const data = response.data;
+
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, data }));
+      } else {
+        console.log(chalk.green('\n✓ Mould stock-in created successfully\n'));
+        if (data?.mouldEntityRegFormCode) {
+          console.log(`  ${chalk.gray('Form Code:')} ${chalk.green(data.mouldEntityRegFormCode)}`);
+        }
+        if (data?.mouldEntityRegFormId) {
+          console.log(`  ${chalk.gray('Form ID:')} ${data.mouldEntityRegFormId}`);
+        }
+        if (data?.stockDate) {
+          console.log(`  ${chalk.gray('Stock Date:')} ${data.stockDate}`);
+        }
+        if (data?.mainWarehouseName) {
+          console.log(`  ${chalk.gray('Warehouse:')} ${data.mainWarehouseName}`);
+        }
+        if (data?.followerName) {
+          console.log(`  ${chalk.gray('Follower:')} ${data.followerName}`);
+        }
+        if (data?.status) {
+          console.log(`  ${chalk.gray('Status:')} ${data.status}`);
+        }
+        console.log();
+      }
+    }
+  });
+
+  return cmd;
+}

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

@@ -0,0 +1,153 @@
+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';
+import { Operation } from '../../../types/operation.js';
+
+export function createOperationActiveCommand(): Command {
+  const activeCommand = new Command('active');
+  activeCommand
+    .description('Enable (activate) operation(s)')
+    .argument('[operation-id]', 'Operation ID (mutually exclusive with --ids)')
+    .option('--ids <ids>', 'Comma-separated operation IDs for batch operations')
+    .option('--force', 'Execute the operation (skip dry-run preview)')
+    .option('--dry-run', 'Preview the operation without executing (default)')
+    .option('--json', 'Output as JSON')
+    .action(async (operationId: string | undefined, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+      const force = options.force === true;
+      const dryRun = !force;
+
+      const batchIds = options.ids
+        ? (options.ids as string).split(',').map((id) => id.trim()).filter((id) => id !== '')
+        : [];
+
+      const jsonOutput = options.json === true;
+
+      if (!operationId && batchIds.length === 0) {
+        const errMsg = 'Invalid operation ID. Provide <operation-id> or use --ids for batch operations.';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'INVALID_ID', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      const allIds = operationId ? [operationId] : batchIds;
+
+      if (!jsonOutput) {
+        console.log(chalk.bold(`\n↑  Enable Operation(s) (${environment})\n`));
+        if (batchIds.length > 0) {
+          console.log(chalk.gray(`  Operation IDs: ${batchIds.join(', ')}`));
+        } else {
+          console.log(chalk.gray(`  Operation ID: ${operationId}`));
+        }
+      }
+
+      if (dryRun) {
+        if (jsonOutput) {
+          console.log(JSON.stringify({
+            success: true,
+            dryRun: true,
+            operationIds: allIds,
+            message: 'No actual API call will be made',
+          }));
+        } else {
+          console.log(chalk.cyan('\n🔍 Dry-Run Mode: No actual API call will be made\n'));
+          console.log(chalk.gray(`  This operation will enable ${allIds.length} operation(s).`));
+          console.log(chalk.gray('\n  To execute, add --force flag.\n'));
+        }
+        return;
+      }
+
+      const operations: Operation[] = [];
+      for (const id of allIds) {
+        try {
+          const response = await apiClient.getOperationDetail(environment, tenant, id);
+          if (!response.success || !response.data || !('operationId' in response.data)) {
+            const errMsg = `Operation not found: ${id}`;
+            if (jsonOutput) {
+              console.log(JSON.stringify({ success: false, error: { code: 'NOT_FOUND', message: errMsg } }));
+            } else {
+              console.error(chalk.red(`\n✗ ${errMsg}\n`));
+            }
+            process.exit(1);
+          }
+          operations.push(response.data as Operation);
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : 'Unknown error';
+          const jsonErr = { success: false, error: { code: 'FETCH_ERROR', message: 'Failed to fetch operation: ' + errMsg } };
+          if (jsonOutput) {
+            console.log(JSON.stringify(jsonErr));
+          } else {
+            console.error(chalk.red(`\n✗ Failed to fetch operation: ${errMsg}\n`));
+          }
+          process.exit(1);
+        }
+      }
+
+      const allAlreadyEnabled = operations.every((op) => op.statusFlag === 1);
+      if (allAlreadyEnabled) {
+        const names = operations.map((op) => `"${op.operationName}"`).join(', ');
+        const errMsg = `Operation(s) ${names} ${operations.length === 1 ? 'is' : 'are'} already enabled`;
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'ALREADY_ENABLED', message: errMsg } }));
+        } else {
+          console.error(chalk.yellow(`\n⚠ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      if (!jsonOutput) {
+        if (operations.length === 1) {
+          console.log(chalk.gray(`  Name: ${operations[0].operationName}`));
+          console.log(chalk.gray(`  Code: ${operations[0].operationCode}`));
+        } else {
+          operations.forEach((op, i) => {
+            console.log(chalk.gray(`  [${i + 1}] ${op.operationName} (${op.operationCode})`));
+          });
+        }
+        console.log();
+      }
+
+      try {
+        const response = await apiClient.batchActiveOperations(environment, tenant, allIds);
+
+        if (response.success) {
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, operationIds: allIds }));
+          } else {
+            const names = operations.map((op) => op.operationName).join(', ');
+            console.log(chalk.green(`\n✓ Operation(s) ${names || allIds.join(', ')} enabled\n`));
+          }
+        } else {
+          const errorMsg = response.error?.message || 'Unknown error';
+          const errorCode = response.error?.code || 'ACTIVE_ERROR';
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+          } else {
+            console.error(chalk.red(`\n✗ Failed to enable operation(s): ${errorMsg}`));
+            if (response.error?.code) {
+              console.error(chalk.gray(`  Error code: ${response.error.code}`));
+            }
+            console.error();
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'ERROR', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+    });
+
+  return activeCommand;
+}