@newpeak/barista-cli 0.1.8 → 0.1.9

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/core/api/client.ts

@@ -94,6 +94,15 @@ import {
   CalendarApiResponse,
   CalendarSetRequest,
 } from '../../types/calendar.js';
+import {
+  MouldEntityQueryParams,
+  MouldEntitySetStatusRequest,
+  MouldEntityApiResponse,
+} from '../../types/mould.js';
+import {
+  MouldEntityRegFormRequest,
+  MouldEntityRegFormApiResponse,
+} from '../../types/mould-stock-in.js';
 
 export interface LoginResponse {
   token: string;
@@ -285,6 +294,7 @@ export function createAPIClient(service: Service, environment: Environment, tena
 
 const orgCache = new Map<string, { items: OrgListItem[]; timestamp: number }>();
 const positionCache = new Map<string, { items: PositionListItem[]; timestamp: number }>();
+const dictItemsCache = new Map<string, { items: { dictCode: string; dictName: string }[]; timestamp: number }>();
 const CACHE_TTL_MS = 5 * 60 * 1000;
 
 export const apiClient = {
@@ -766,6 +776,40 @@ const response = await client.getClient().get<DictTypeApiResponse>(
     }
   },
 
+  async getDictItems(
+    environment: Environment,
+    tenant: string,
+    dictTypeCode: string
+  ): Promise<{ success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } }> {
+    const cacheKey = `${environment}:${tenant}:${dictTypeCode}`;
+    const cached = dictItemsCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+      return { success: true, data: cached.items };
+    }
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<{ success: boolean; data?: { dictCode: string; dictName: string }[]; message?: string }>(
+        `/api/enterprise/master/dict/list?dictTypeCode=${dictTypeCode}`
+      );
+      if (response.data?.success && response.data?.data) {
+        dictItemsCache.set(cacheKey, { items: response.data.data, timestamp: Date.now() });
+        return { success: true, data: response.data.data };
+      }
+      if (response.data?.success && Array.isArray(response.data?.data)) {
+        dictItemsCache.set(cacheKey, { items: response.data.data as any, timestamp: Date.now() });
+        return { success: true, data: response.data.data as any };
+      }
+      return response.data as { success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } };
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: { dictCode: string; dictName: string }[]; error?: { code: string; message: string } };
+    }
+  },
+
   async getOperationCode(
     environment: Environment,
     tenant: string
@@ -1818,6 +1862,125 @@ const response = await client.getClient().get<DictTypeApiResponse>(
     }
   },
 
+  async listMouldEntities(
+    environment: Environment,
+    tenant: string,
+    params: MouldEntityQueryParams
+  ): Promise<MouldEntityApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      // CLI page 1 → API pageNo 0 (subtract 1)
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', (params.pageNo - 1).toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.mouldEntityId) queryString.append('mouldEntityId', params.mouldEntityId);
+      if (params.mouldEntityCode) queryString.append('mouldEntityCode', params.mouldEntityCode);
+      if (params.materialCode) queryString.append('materialCode', params.materialCode);
+      if (params.materialNo) queryString.append('materialNo', params.materialNo);
+      if (params.materialName) queryString.append('materialName', params.materialName);
+      if (params.seqNo) queryString.append('seqNo', params.seqNo);
+      if (params.lotNo) queryString.append('lotNo', params.lotNo);
+      if (params.mouldType) queryString.append('mouldType', params.mouldType);
+      if (params.mouldFaceNumber) queryString.append('mouldFaceNumber', params.mouldFaceNumber.toString());
+      if (params.mouldStatus) queryString.append('mouldStatus', params.mouldStatus);
+      if (params.currentWarehouseCode) queryString.append('currentWarehouseCode', params.currentWarehouseCode);
+      const url = `/api/enterprise/manufacture/mouldEntity/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<MouldEntityApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async getMouldEntity(
+    environment: Environment,
+    tenant: string,
+    id: string
+  ): Promise<MouldEntityApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityApiResponse>(
+        '/api/enterprise/manufacture/mouldEntity/detail',
+        { mouldEntityId: id }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async setMouldStatus(
+    environment: Environment,
+    tenant: string,
+    request: MouldEntitySetStatusRequest
+  ): Promise<MouldEntityApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityApiResponse>(
+        '/api/enterprise/manufacture/mouldEntity/setMouldStatus',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error);
+    }
+  },
+
+  async createMouldStockIn(
+    environment: Environment,
+    tenant: string,
+    request: MouldEntityRegFormRequest
+  ): Promise<MouldEntityRegFormApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+
+      const codeResponse = await this.getCodeByType(environment, tenant, 'TenantMouldRegFormCode');
+      if (!codeResponse.success || !codeResponse.data) {
+        return { success: false, error: { code: 'CODE_GENERATION_FAILED', message: codeResponse.error?.message || 'Failed to generate form code' } };
+      }
+      request.mouldEntityRegFormCode = codeResponse.data;
+
+      for (const item of request.itemList) {
+        if (!item.mouldEntityRegFormItemCode) {
+          const itemCodeResponse = await this.getCodeByType(environment, tenant, 'TenantMouldRegFormItemCode');
+          if (!itemCodeResponse.success || !itemCodeResponse.data) {
+            return { success: false, error: { code: 'CODE_GENERATION_FAILED', message: itemCodeResponse.error?.message || 'Failed to generate item code' } };
+          }
+          item.mouldEntityRegFormItemCode = itemCodeResponse.data;
+        }
+      }
+
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<MouldEntityRegFormApiResponse>(
+        '/api/enterprise/manufacture/mouldEntityRegForm/add',
+        request
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiErrorMould(error) as unknown as MouldEntityRegFormApiResponse;
+    }
+  },
+
   async listUoms(
     environment: Environment,
     tenant: string,
@@ -3210,4 +3373,43 @@ function handleApiErrorStock(error: unknown): MasterStockApiResponse {
       message: error instanceof Error ? error.message : 'Unknown error occurred',
     },
   };
+}
+
+function handleApiErrorMould(error: unknown): MouldEntityApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as MouldEntityApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
 }

package/src/index.ts

@@ -15,7 +15,7 @@ async function main(): Promise<void> {
     program
       .name('barista')
       .description('Barista CLI - Bridge between AI agents and Liberica/Arabica')
-      .version('0.1.8')
+      .version('0.1.9')
       .option('-e, --env <environment>', 'Target environment (dev|test|prod-cn|prod-jp)')
       .option('-t, --tenant <tenant>', 'Target tenant (for Liberica)')
       .option('--debug', 'Enable debug mode');

package/src/types/index.ts

@@ -84,3 +84,5 @@ export type { DictType, DictItem, DictTypeListResponse, DictItemListResponse, Di
 export type { MasterStockQueryParams, MasterWarehouseStockItem, MasterStockPageResult, MasterStockApiResponse, StockFlag, StockJourneyQueryParams, StockJourneyItem, StockJourneyApiResponse, StockJourneySummary, StockJourneySummaryApiResponse } from './stock.js';
 export type { ClientContact, CreateClientContactRequest, UpdateClientContactRequest, ClientContactQueryParams, ClientContactListResponse, ClientContactApiResponse } from './client-contact.js';
 export type { SupplierContact, CreateSupplierContactRequest, UpdateSupplierContactRequest, SupplierContactQueryParams, SupplierContactListResponse, SupplierContactApiResponse } from './supplier-contact.js';
+export type { MouldEntity, MouldEntityQueryParams, MouldEntityListResponse, MouldEntitySetStatusRequest, MouldEntityApiResponse, MouldStatus, MouldStatusFlag } from './mould.js';
+export type { MouldEntityRegFormRequest, MouldEntityRegFormItemRequest, MouldEntityRegFormApiResponse, MouldEntityRegFormData, MouldEntityRegFormItemResponse, MouldEntityRegFormListResponse } from './mould-stock-in.js';

package/src/types/material.ts

@@ -16,7 +16,7 @@ export interface MaterialRequest {
   materialName: string;
   materialClass: string;
   materialType?: string;
-  materialUnit?: string;
+  materialUomCode?: string;
   materialCode?: string;
   materialNo?: string;
 }

package/src/types/mould-stock-in.ts

@@ -0,0 +1,82 @@
+// Mould stock-in (入库单) types
+
+// Stock-in form item request
+export interface MouldEntityRegFormItemRequest {
+  mouldEntityRegFormItemCode?: string;
+  materialCode: string;
+  materialNo?: string;
+  materialName?: string;
+  materialType?: string;
+  formQuantity: number;
+  formMaterialUomCode?: string;
+  materialUomCode?: string;
+  producedDate?: string;
+  mouldType?: string;
+  mouldFaceNumber?: number;
+  warehouseCode?: string;
+  remark?: string;
+}
+
+// Stock-in form request
+export interface MouldEntityRegFormRequest {
+  mouldEntityRegFormCode: string;
+  stockDate?: string;
+  mainWarehouseCode: string;
+  follower: string;
+  followerName?: string;
+  remark?: string;
+  itemList: MouldEntityRegFormItemRequest[];
+}
+
+// API response wrapper for stock-in forms
+export interface MouldEntityRegFormApiResponse {
+  success: boolean;
+  data?: MouldEntityRegFormData;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+// Stock-in form data response
+export interface MouldEntityRegFormData {
+  mouldEntityRegFormId: string;
+  mouldEntityRegFormCode: string;
+  stockDate?: string;
+  mainWarehouseCode?: string;
+  mainWarehouseName?: string;
+  follower?: string;
+  followerName?: string;
+  remark?: string;
+  status?: string;
+  itemList?: MouldEntityRegFormItemResponse[];
+  createdBy?: string;
+  createdTime?: string;
+  updatedBy?: string;
+  updatedTime?: string;
+}
+
+// Stock-in form item response
+export interface MouldEntityRegFormItemResponse {
+  mouldEntityRegFormItemId: string;
+  mouldEntityRegFormId: string;
+  materialCode?: string;
+  materialNo?: string;
+  materialName?: string;
+  materialType?: string;
+  formQuantity?: number;
+  producedDate?: string;
+  mouldType?: string;
+  mouldFaceNumber?: number;
+  warehouseCode?: string;
+  warehouseName?: string;
+  remark?: string;
+}
+
+// List response for stock-in forms
+export interface MouldEntityRegFormListResponse {
+  totalRows: number;
+  pageSize: number;
+  pageNo: number;
+  rows: MouldEntityRegFormData[];
+}

package/src/types/mould.ts

@@ -0,0 +1,74 @@
+// Mould status literal type
+export type MouldStatus = 'FINE' | 'REPAIR' | 'SCRAP';
+
+// Status flag literal type
+export type MouldStatusFlag = 1 | 2;
+
+// Full Mould entity (from MouldEntityResponse)
+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;
+}
+
+// Query params for list/pagination
+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;
+}
+
+// Paginated response wrapper (PageResult from Roses framework)
+export interface PageResult<T> {
+  totalRows: number;
+  pageSize: number;
+  pageNo: number;
+  rows: T[];
+}
+
+// List response type
+export interface MouldEntityListResponse extends PageResult<MouldEntity> {}
+
+// Request for setting mould status (set-status API)
+export interface MouldEntitySetStatusRequest {
+  mouldEntityId: string;
+  tenantId?: string;
+  mouldStatus: MouldStatus;
+  remark?: string;
+}
+
+// API response wrapper
+export interface MouldEntityApiResponse {
+  success: boolean;
+  data?: MouldEntity | MouldEntityListResponse;
+  error?: {
+    code: string;
+    message: string;
+  };
+}