@newpeak/barista-cli 0.1.8 → 0.1.9

package/dist/types/mould-stock-in.js

@@ -0,0 +1,3 @@
+// Mould stock-in (入库单) types
+export {};
+//# sourceMappingURL=mould-stock-in.js.map

package/dist/types/mould-stock-in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mould-stock-in.js","sourceRoot":"","sources":["../../src/types/mould-stock-in.ts"],"names":[],"mappings":"AAAA,6BAA6B"}

package/dist/types/mould.d.ts

@@ -0,0 +1,61 @@
+export type MouldStatus = 'FINE' | 'REPAIR' | 'SCRAP';
+export type MouldStatusFlag = 1 | 2;
+export interface MouldEntity {
+    mouldEntityId: string;
+    mouldEntityCode: string;
+    mouldEntityRegFormItemId?: string;
+    tenantId?: string;
+    materialCode?: string;
+    materialNo?: string;
+    materialName?: string;
+    seqNo?: string;
+    lotNo?: string;
+    mouldType?: string;
+    mouldFaceNumber?: number;
+    mouldStatus?: MouldStatus;
+    currentWarehouseCode?: string;
+    unitPrice?: number;
+    currency?: string;
+    producedDate?: string;
+    lastStockOutTime?: string;
+    remark?: string;
+}
+export interface MouldEntityQueryParams {
+    pageNo?: number;
+    pageSize?: number;
+    status?: MouldStatusFlag;
+    mouldEntityId?: string;
+    mouldEntityCode?: string;
+    materialCode?: string;
+    materialNo?: string;
+    materialName?: string;
+    seqNo?: string;
+    lotNo?: string;
+    mouldType?: string;
+    mouldFaceNumber?: number;
+    mouldStatus?: MouldStatus;
+    currentWarehouseCode?: string;
+}
+export interface PageResult<T> {
+    totalRows: number;
+    pageSize: number;
+    pageNo: number;
+    rows: T[];
+}
+export interface MouldEntityListResponse extends PageResult<MouldEntity> {
+}
+export interface MouldEntitySetStatusRequest {
+    mouldEntityId: string;
+    tenantId?: string;
+    mouldStatus: MouldStatus;
+    remark?: string;
+}
+export interface MouldEntityApiResponse {
+    success: boolean;
+    data?: MouldEntity | MouldEntityListResponse;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+//# sourceMappingURL=mould.d.ts.map

package/dist/types/mould.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mould.d.ts","sourceRoot":"","sources":["../../src/types/mould.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAGtD,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,CAAC,CAAC;AAGpC,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAGD,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,CAAC,EAAE,CAAC;CACX;AAGD,MAAM,WAAW,uBAAwB,SAAQ,UAAU,CAAC,WAAW,CAAC;CAAG;AAG3E,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,GAAG,uBAAuB,CAAC;IAC7C,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH"}

package/dist/types/mould.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mould.js.map

package/dist/types/mould.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mould.js","sourceRoot":"","sources":["../../src/types/mould.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newpeak/barista-cli",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "AI Tools CLI for Liberica and Arabica services",
   "type": "module",
   "bin": "./bin/barista",

package/src/commands/liberica/index.ts

@@ -20,6 +20,7 @@ import { createStockCommand } from './stock/index.js';
 import { createCalendarCommand } from './calendar/index.js';
 import { createClientContactsCommand } from './client-contacts/index.js';
 import { createSupplierContactsCommand } from './supplier-contacts/index.js';
+import { createMouldCommand } from './mould/index.js';
 
 export function createLibericaCommand(): Command {
   const libericaCommand = new Command('liberica');
@@ -45,6 +46,7 @@ export function createLibericaCommand(): Command {
   libericaCommand.addCommand(createCalendarCommand());
   libericaCommand.addCommand(createClientContactsCommand());
   libericaCommand.addCommand(createSupplierContactsCommand());
+  libericaCommand.addCommand(createMouldCommand());
 
   libericaCommand.action(() => {
     console.log(chalk.bold('\n☕ Liberica Commands\n'));

package/src/commands/liberica/materials/create.ts

@@ -12,7 +12,7 @@ function formatTable(data: MaterialRequest): string {
   lines.push(`  ${chalk.gray('Code:')}         ${data.materialCode}`);
   lines.push(`  ${chalk.gray('Class:')}        ${data.materialClass || '(not set)'}`);
   if (data.materialType) lines.push(`  ${chalk.gray('Type:')}         ${data.materialType}`);
-  if (data.materialUnit) lines.push(`  ${chalk.gray('Unit:')}         ${data.materialUnit}`);
+  if (data.materialUomCode) lines.push(`  ${chalk.gray('Unit:')}         ${data.materialUomCode}`);
   return lines.join('\n');
 }
 
@@ -36,7 +36,7 @@ export function createMaterialsCreateCommand(): Command {
     let materialNo = (options.no as string | undefined) || (options['no'] as string | undefined);
     let materialClass = options.class as string | undefined;
     const materialType = options.type as string | undefined;
-    const materialUnit = options.unit as string | undefined;
+    const materialUomCode = options.unit as string | undefined;
     const dryRun = options.dryRun === true;
     const outputJson = options.json === true;
 
@@ -100,6 +100,14 @@ export function createMaterialsCreateCommand(): Command {
       materialNo = inputNo;
     }
 
+    const dictResponse = await apiClient.getDictItems(context.environment, context.tenant, 'MATERIAL_CLASS');
+    if (dictResponse.success && dictResponse.data) {
+      const matchedItem = dictResponse.data.find(item => item.dictName === materialClass);
+      if (matchedItem) {
+        materialClass = matchedItem.dictCode;
+      }
+    }
+
     const codeResponse = await apiClient.getCodeByType(context.environment, context.tenant, 'TenantMaterialCode');
     if (!codeResponse.success || !codeResponse.data) {
       const errMsg = codeResponse.error?.message || 'Failed to generate material code';
@@ -118,7 +126,7 @@ export function createMaterialsCreateCommand(): Command {
       materialCode: materialCode,
       materialClass: materialClass!,
       materialType: materialType,
-      materialUnit: materialUnit,
+      materialUomCode: materialUomCode,
     };
 
     if (dryRun) {
@@ -162,7 +170,7 @@ export function createMaterialsCreateCommand(): Command {
         materialName?: string;
         materialClass?: string;
         materialType?: string;
-        materialUnit?: string;
+        materialUomCode?: string;
         statusFlag?: number;
         createTime?: string;
       } | undefined;
@@ -177,7 +185,7 @@ export function createMaterialsCreateCommand(): Command {
         if (material?.materialCode) console.log(`  ${chalk.gray('Code:')}         ${material.materialCode}`);
         if (material?.materialClass) console.log(`  ${chalk.gray('Class:')}        ${material.materialClass}`);
         if (material?.materialType) console.log(`  ${chalk.gray('Type:')}         ${material.materialType}`);
-        if (material?.materialUnit) console.log(`  ${chalk.gray('Unit:')}         ${material.materialUnit}`);
+        if (material?.materialUomCode) console.log(`  ${chalk.gray('Unit:')}         ${material.materialUomCode}`);
         if (material?.statusFlag !== undefined) {
           const statusText = material.statusFlag === 1 ? 'Enabled' : 'Disabled';
           console.log(`  ${chalk.gray('Status:')}       ${chalk.green(statusText)}`);

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

@@ -25,7 +25,7 @@ export function createMaterialUpdateCommand(): Command {
       if (options.name) fields.materialName = options.name as string;
       if (options.class) fields.materialClass = options.class as string;
       if (options.type) fields.materialType = options.type as string;
-      if (options.unit) fields.materialUnit = options.unit as string;
+      if (options.unit) fields.materialUomCode = options.unit as string;
 
       const providedFields = Object.keys(fields).filter(
         (k) => fields[k as keyof MaterialRequest] !== undefined

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

@@ -0,0 +1,111 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { MouldEntityApiResponse, MouldEntity } from '../../../types/mould.js';
+
+function formatMouldStatus(status?: string): string {
+  if (!status) return chalk.gray('-');
+  switch (status) {
+    case 'FINE':
+      return chalk.green('FINE');
+    case 'REPAIR':
+      return chalk.yellow('REPAIR');
+    case 'SCRAP':
+      return chalk.red('SCRAP');
+    default:
+      return status;
+  }
+}
+
+function outputMouldDetails(mould: MouldEntity): void {
+  console.log(chalk.bold('\n🔧 Mould Details\n'));
+
+  console.log(chalk.gray('  ID:               ') + mould.mouldEntityId);
+  console.log(chalk.gray('  Code:             ') + (mould.mouldEntityCode || chalk.gray('-')));
+  console.log(chalk.gray('  Material Code:    ') + (mould.materialCode || chalk.gray('-')));
+  console.log(chalk.gray('  Material Name:    ') + (mould.materialName || chalk.gray('-')));
+  console.log(chalk.gray('  Material No:      ') + (mould.materialNo || chalk.gray('-')));
+  console.log(chalk.gray('  Type:             ') + (mould.mouldType || chalk.gray('-')));
+  console.log(chalk.gray('  Status:           ') + formatMouldStatus(mould.mouldStatus));
+  console.log(chalk.gray('  Warehouse Code:   ') + (mould.currentWarehouseCode || chalk.gray('-')));
+  console.log(chalk.gray('  Seq No:           ') + (mould.seqNo || chalk.gray('-')));
+  console.log(chalk.gray('  Lot No:           ') + (mould.lotNo || chalk.gray('-')));
+  console.log(chalk.gray('  Face Number:      ') + (mould.mouldFaceNumber !== undefined ? String(mould.mouldFaceNumber) : chalk.gray('-')));
+  console.log(chalk.gray('  Unit Price:       ') + (mould.unitPrice !== undefined ? `${mould.unitPrice} ${mould.currency || ''}` : chalk.gray('-')));
+  console.log(chalk.gray('  Produced Date:    ') + (mould.producedDate || chalk.gray('-')));
+  console.log(chalk.gray('  Last Stock Out:   ') + (mould.lastStockOutTime || chalk.gray('-')));
+  console.log(chalk.gray('  Remark:           ') + (mould.remark || chalk.gray('-')));
+  console.log();
+}
+
+export function createMouldGetCommand(): Command {
+  const getCommand = new Command('get');
+  getCommand.description('Get mould entity details by ID');
+
+  getCommand
+    .argument('<mouldEntityId>', 'Mould entity ID (BigInteger string)')
+    .option('--json', 'Output as JSON')
+    .action(async (mouldEntityId: string, options: { json?: boolean }) => {
+      if (!mouldEntityId) {
+        console.error(chalk.red('\n✗ Mould ID is required\n'));
+        process.exit(1);
+      }
+
+      const context = configManager.getCurrentContext();
+      const environment = context.environment;
+      const tenant = context.tenant;
+
+      const response: MouldEntityApiResponse = await apiClient.getMouldEntity(
+        environment,
+        tenant,
+        mouldEntityId
+      );
+
+      if (!response.success) {
+        const errorMessage = response.error?.message || 'Unknown error';
+        const errorCode = response.error?.code;
+
+        if (errorMessage.includes('不存在') || errorMessage.includes('not exist')) {
+          console.error(chalk.red(`\n✗ Mould not found: ${mouldEntityId}\n`));
+        } else {
+          console.error(chalk.red(`\n✗ Failed to get mould: ${errorMessage}`));
+          if (errorCode) {
+            console.error(chalk.gray(`  Error code: ${errorCode}`));
+          }
+          console.error();
+        }
+        process.exit(1);
+      }
+
+      const data = response.data as MouldEntity | null;
+
+      if (!data) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: null }, null, 2));
+        } else {
+          console.log(chalk.bold('\n🔧 Mould Details\n'));
+          console.log(chalk.gray('  Not found\n'));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data,
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+
+      outputMouldDetails(data);
+    });
+
+  return getCommand;
+}

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

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { createMouldListCommand } from './list.js';
+import { createMouldGetCommand } from './get.js';
+import { createMouldSetStatusCommand } from './set-status.js';
+import { createMouldStockInCommand } from './stock-in.js';
+
+export function createMouldCommand(): Command {
+  const mouldCommand = new Command('mould');
+  mouldCommand.description('Manage mould entities');
+
+  mouldCommand.addCommand(createMouldListCommand());
+  mouldCommand.addCommand(createMouldGetCommand());
+  mouldCommand.addCommand(createMouldSetStatusCommand());
+  mouldCommand.addCommand(createMouldStockInCommand());
+
+  return mouldCommand;
+}

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;
+}