@newpeak/barista-cli 0.1.6 → 0.1.8

package/src/commands/liberica/dict-types/update.ts

@@ -0,0 +1,134 @@
+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 { DictType, UpdateDictTypeRequest } from '../../../types/dict.js';
+
+export function createDictTypeUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand
+    .description('Update dictionary type')
+    .argument('<dict-type-id>', 'Dictionary Type ID')
+    .option('-c, --code <code>', 'Dictionary type code')
+    .option('-n, --name <name>', 'Dictionary type name')
+    .option('-s, --status <status>', 'Status (1: enable, 2: disable)')
+    .option('--sort <sort>', 'Sort order')
+    .option('--dry-run', 'Preview changes without making API call')
+    .option('--json', 'Output result as JSON')
+    .action(async (dictTypeId: string, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+
+      const fields: Partial<UpdateDictTypeRequest> = {};
+      if (options.code) fields.dictTypeCode = options.code as string;
+      if (options.name) fields.dictTypeName = options.name as string;
+      if (options.status) {
+        const status = parseInt(options.status as string, 10);
+        if (status === 1 || status === 2) {
+          fields.statusFlag = status as 1 | 2;
+        } else {
+          console.error(chalk.red('\n✗ Invalid status. Use 1 (enable) or 2 (disable)\n'));
+          process.exit(1);
+        }
+      }
+      if (options.sort) {
+        const sortOrder = parseInt(options.sort as string, 10);
+        if (!isNaN(sortOrder)) {
+          fields.sortOrder = sortOrder;
+        }
+      }
+
+      const providedFields = Object.keys(fields).filter(
+        (k) => fields[k as keyof UpdateDictTypeRequest] !== undefined && k !== 'dictTypeId'
+      );
+      if (providedFields.length === 0) {
+        console.error(
+          chalk.red('\n✗ No fields to update. Provide at least one of: --code, --name, --status, --sort\n')
+        );
+        process.exit(1);
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.bold(`\n📖 Update Dict Type — Dry Run (${environment})\n`));
+        console.log(chalk.gray(`  Dict Type ID: ${dictTypeId}`));
+        console.log(chalk.gray('\n  Changes to be applied:'));
+        for (const field of providedFields) {
+          const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+          console.log(chalk.cyan(`    ${label}: "${fields[field as keyof UpdateDictTypeRequest]}"`));
+        }
+        console.log();
+        return;
+      }
+
+      let currentDictType: DictType | undefined;
+      try {
+        const dictTypeResponse = await apiClient.getDictType(environment, tenant, dictTypeId);
+        if (!dictTypeResponse.success || !dictTypeResponse.data) {
+          console.error(chalk.red(`\n✗ Dictionary type not found: ${dictTypeId}`));
+          if (dictTypeResponse.error?.message) {
+            console.error(chalk.gray(`  ${dictTypeResponse.error.message}`));
+          }
+          if (dictTypeResponse.error?.code) {
+            console.error(chalk.gray(`  Error code: ${dictTypeResponse.error.code}`));
+          }
+          console.error();
+          process.exit(1);
+        }
+        currentDictType = dictTypeResponse.data as DictType;
+      } catch (error) {
+        console.error(chalk.red(`\n✗ Failed to fetch dictionary type: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.bold(`\n📖 Update Dict Type (${environment})\n`));
+      console.log(chalk.gray(`  Dict Type ID: ${dictTypeId}`));
+      console.log(chalk.gray(`  Current Name: ${currentDictType.dictTypeName}`));
+      console.log(chalk.gray('\n  Changes:'));
+      for (const field of providedFields) {
+        const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+        const currentVal = (currentDictType as unknown as Record<string, unknown>)[field] ?? '(not set)';
+        const newVal = fields[field as keyof UpdateDictTypeRequest];
+        console.log(chalk.cyan(`    ${label}: "${currentVal}" → "${newVal}"`));
+      }
+
+      const updateData: UpdateDictTypeRequest = { dictTypeId, ...fields };
+      try {
+        const response = await apiClient.updateDictType(environment, tenant, updateData);
+
+        if (response.success) {
+          if (options.json) {
+            console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+          } else {
+            console.log(chalk.green('\n✓ Dictionary type updated successfully\n'));
+          }
+        } else {
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: response.error }, null, 2));
+          } else {
+            console.error(chalk.red(`\n✗ Update failed: ${response.error?.message || 'Unknown error'}`));
+            if (response.error?.code) {
+              console.error(chalk.gray(`  Error code: ${response.error.code}`));
+            }
+            console.error();
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { message: error instanceof Error ? error.message : 'Unknown error' },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        }
+        process.exit(1);
+      }
+    });
+
+  return updateCommand;
+}

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

@@ -0,0 +1,175 @@
+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 { CreateDictItemRequest, DictType } from '../../../types/dict.js';
+
+function formatTable(data: CreateDictItemRequest): string {
+  const lines: string[] = [];
+  lines.push(`  ${chalk.gray('Dict Type Code:')} ${data.dictTypeCode || '(not set)'}`);
+  lines.push(`  ${chalk.gray('Code:')}           ${data.dictCode || '(not set)'}`);
+  lines.push(`  ${chalk.gray('Name:')}           ${data.dictName || '(not set)'}`);
+  if (data.dictValue) lines.push(`  ${chalk.gray('Value:')}          ${data.dictValue}`);
+  if (data.sortOrder !== undefined) lines.push(`  ${chalk.gray('Sort Order:')}     ${data.sortOrder}`);
+  if (data.statusFlag) lines.push(`  ${chalk.gray('Status:')}        ${data.statusFlag === 1 ? 'Enabled' : 'Disabled'}`);
+  if (data.remark) lines.push(`  ${chalk.gray('Remark:')}         ${data.remark}`);
+  return lines.join('\n');
+}
+
+export function createDictCreateCommand(): Command {
+  const cmd = new Command('create');
+  cmd.description('Create a new dictionary item');
+
+  cmd
+    .requiredOption('-t, --type-code <string>', 'Dict type code (e.g., ID_TYPE, sex) (required)')
+    .requiredOption('-c, --code <string>', 'Dict code (required)')
+    .requiredOption('-n, --name <string>', 'Dict name (required)')
+    .option('-p, --parent <string>', 'Parent dict ID (-1 for root)', '-1')
+    .option('-s, --status <string>', 'Status (1=enable, 2=disable)', '1')
+    .option('-o, --sort <number>', 'Sort order', '0')
+    .option('-v, --value <string>', 'Dict value')
+    .option('-r, --remark <text>', 'Remark')
+    .option('--dry-run', 'Preview without making API call')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async () => {
+    const context = configManager.getCurrentContext();
+    const opts = cmd.opts();
+
+    let typeCode = opts.typeCode as string | undefined;
+    const code = opts.code as string | undefined;
+    const name = opts.name as string | undefined;
+    const parentId = (opts.parent as string) === '-1' ? '-1' : (opts.parent as string);
+    const statusFlag = parseInt(opts.status as string, 10) || 1;
+    const sortOrder = parseInt(opts.sort as string, 10) || 0;
+    const dictValue = opts.value as string | undefined;
+    const remark = opts.remark as string | undefined;
+    const dryRun = opts.dryRun === true;
+    const outputJson = opts.json === true || process.argv.includes('--json');
+
+    if (!typeCode) {
+      const { inputTypeCode } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'inputTypeCode',
+          message: 'Enter dict type code (e.g., ID_TYPE, sex):',
+          validate: (input: string) => input.trim().length > 0 || 'Dict type code is required',
+        },
+      ]);
+typeCode = inputTypeCode;
+    }
+
+    // Look up dictTypeId from typeCode before creating
+    const dictTypeResponse = await apiClient.listDictTypes(
+      context.environment,
+      context.tenant,
+      { dictTypeCode: typeCode, pageSize: 100 }
+    );
+
+    if (!dictTypeResponse.success || !dictTypeResponse.data) {
+      if (outputJson) {
+        console.log(JSON.stringify({ success: false, error: { code: 'DICT_TYPE_NOT_FOUND', message: `Dict type not found: ${typeCode}` } }));
+      } else {
+        console.error(chalk.red(`\n✗ Dict type not found: ${typeCode}\n`));
+      }
+      process.exit(1);
+    }
+
+    // response.data is an array of DictType since the API returns plain array
+    const dictTypes = dictTypeResponse.data as unknown as DictType[];
+    const matchedDictType = dictTypes.find(dt => dt.dictTypeCode === typeCode);
+
+    if (!matchedDictType) {
+      if (outputJson) {
+        console.log(JSON.stringify({ success: false, error: { code: 'DICT_TYPE_NOT_FOUND', message: `Dict type not found: ${typeCode}` } }));
+      } else {
+        console.error(chalk.red(`\n✗ Dict type not found: ${typeCode}\n`));
+      }
+      process.exit(1);
+    }
+
+    const dictTypeId = matchedDictType.dictTypeId;
+
+    const data: CreateDictItemRequest = {
+      dictTypeId: dictTypeId,
+      dictCode: code!,
+      dictName: name!,
+      dictValue: dictValue || name!,
+      sortOrder: sortOrder,
+      statusFlag: statusFlag as 1 | 2,
+      remark: remark,
+    };
+
+    // Add parent and predefinedFlag as additional fields
+    data.dictParentId = parentId;
+    data.predefinedFlag = 'N';
+
+    if (dryRun) {
+      if (outputJson) {
+        console.log(JSON.stringify({ success: true, dryRun: true, data }));
+      } else {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode: No changes will be made\n'));
+        console.log('  Dict item to be created:');
+        console.log(formatTable(data));
+        console.log();
+      }
+      return;
+    }
+
+    if (!outputJson) {
+      console.log(chalk.bold('\n📝 Creating Dict Item\n'));
+    }
+
+    const response = await apiClient.createDictItem(context.environment, context.tenant, data);
+
+    if (!response.success) {
+      const errorMsg = response.error?.message || 'Failed to create dict item';
+      const errorCode = response.error?.code || 'CREATE_DICT_ITEM_ERROR';
+      if (outputJson) {
+        console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ Failed to create dict item: ${errorMsg}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+      }
+      process.exit(1);
+    }
+
+    if (response.success) {
+      const dictItem = response.data as {
+        dictId?: string;
+        dictTypeId?: string;
+        dictCode?: string;
+        dictName?: string;
+        dictValue?: string;
+        sortOrder?: number;
+        statusFlag?: number;
+        remark?: string;
+        createTime?: string;
+      } | undefined;
+
+      if (outputJson) {
+        console.log(JSON.stringify({ success: true, data: dictItem }));
+      } else {
+        console.log(chalk.green('✓ Dict item created successfully\n'));
+        if (dictItem?.dictId) console.log(`  ${chalk.gray('Dict ID:')}     ${chalk.green(String(dictItem.dictId))}`);
+        if (dictItem?.dictTypeId) console.log(`  ${chalk.gray('Type ID:')}      ${dictItem.dictTypeId}`);
+        if (dictItem?.dictCode) console.log(`  ${chalk.gray('Code:')}           ${dictItem.dictCode}`);
+        if (dictItem?.dictName) console.log(`  ${chalk.gray('Name:')}           ${dictItem.dictName}`);
+        if (dictItem?.dictValue) console.log(`  ${chalk.gray('Value:')}          ${dictItem.dictValue}`);
+        if (dictItem?.sortOrder !== undefined) console.log(`  ${chalk.gray('Sort Order:')}     ${dictItem.sortOrder}`);
+        if (dictItem?.statusFlag !== undefined) {
+          const statusText = dictItem.statusFlag === 1 ? 'Enabled' : 'Disabled';
+          console.log(`  ${chalk.gray('Status:')}        ${chalk.green(statusText)}`);
+        }
+        if (dictItem?.remark) console.log(`  ${chalk.gray('Remark:')}         ${dictItem.remark}`);
+        console.log();
+      }
+    }
+  });
+
+  return cmd;
+}

package/src/commands/liberica/dicts/delete.ts

@@ -0,0 +1,107 @@
+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 { DictItem } from '../../../types/dict.js';
+
+export function createDictDeleteCommand(): Command {
+  const deleteCommand = new Command('delete');
+  deleteCommand
+    .description('Delete a dictionary item')
+    .argument('<dictId>', 'Dict Item ID')
+    .option('--force', 'Skip confirmation and delete directly')
+    .option('--dry-run', 'Preview without making API call')
+    .option('--json', 'Output as JSON')
+    .action(async (dictId: string, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+      const dryRun = options.dryRun === true;
+      const jsonOutput = options.json === true;
+
+      if (!jsonOutput) {
+        console.log(chalk.bold(`\n🗑️  Delete Dictionary Item (${environment})\n`));
+        console.log(chalk.gray(`  Dict ID: ${dictId}`));
+      }
+
+      let dictItem: DictItem | undefined;
+      try {
+        const dictResponse = await apiClient.getDictItem(environment, tenant, dictId);
+        if (!dictResponse.success || !dictResponse.data || !('dictId' in dictResponse.data)) {
+          const errMsg = `Dictionary item not found: ${dictId}`;
+          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);
+        }
+        dictItem = dictResponse.data as DictItem;
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'FETCH_ERROR', message: `Failed to fetch dictionary item: ${errMsg}` } }));
+        } else {
+          console.error(chalk.red(`\n✗ Failed to fetch dictionary item: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      if (!jsonOutput) {
+        console.log(chalk.gray(`  Name: ${dictItem.dictName}`));
+        console.log(chalk.gray(`  Code: ${dictItem.dictCode}`));
+        console.log(chalk.gray(`  Value: ${dictItem.dictValue}`));
+        console.log(chalk.gray(`  Type ID: ${dictItem.dictTypeId}`));
+      }
+
+      if (dryRun) {
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: true, dryRun: true, dictItem }));
+        } else {
+          console.log(chalk.cyan('\n🔍 Dry-Run Mode: No actual deletion will be made\n'));
+          console.log(chalk.yellow('  To delete, add: --force\n'));
+        }
+        return;
+      }
+
+      if (!options.force) {
+        return;
+      }
+
+      try {
+        const response = await apiClient.deleteDictItem(environment, tenant, dictId);
+
+        if (response.success) {
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, dictId, name: dictItem.dictName }));
+          } else {
+            console.log(chalk.green(`\n✓ Dictionary Item "${dictItem.dictName}" (ID: ${dictId}) deleted\n`));
+          }
+        } else {
+          const errorMsg = response.error?.message || 'Unknown error';
+          const errorCode = response.error?.code || 'DELETE_ERROR';
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+          } else {
+            console.error(chalk.red(`\n✗ Failed to delete dictionary item: ${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 deleteCommand;
+}

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

@@ -0,0 +1,80 @@
+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 { DictItem } from '../../../types/dict.js';
+
+export function createDictGetCommand(): Command {
+  const getCommand = new Command('get');
+  getCommand.description('Get dictionary item details by ID');
+  getCommand.arguments('<dictId>');
+  getCommand.option('--json', 'Output as JSON');
+
+  getCommand.action(async (dictId: 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 (!dictId) {
+      console.error(chalk.red('\n✗ Dict ID is required\n'));
+      process.exit(1);
+    }
+
+    if (!dictId || dictId.trim() === '') {
+      console.error(chalk.red('\n✗ Invalid dict ID.\n'));
+      process.exit(1);
+    }
+
+    try {
+      const response = await apiClient.getDictItem(environment, tenant, dictId);
+
+      if (!response.success) {
+        const errorCode = response.error?.code || 'UNKNOWN_ERROR';
+        const errorMessage = response.error?.message || 'Unknown error';
+
+        // Handle "dict item not found" case
+        if (errorCode === '01001150001' || errorMessage.includes('不存在')) {
+          console.error(chalk.red(`\n✗ Dictionary item not found: ${dictId}\n`));
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${errorMessage} (${errorCode})\n`));
+        }
+        process.exit(1);
+      }
+
+      const dictItem = response.data as DictItem | null;
+
+      if (!dictItem) {
+        console.error(chalk.red('\n✗ Dictionary item not found\n'));
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({
+          success: true,
+          data: dictItem,
+        }, null, 2));
+        return;
+      }
+
+      // Table output
+      console.log(chalk.bold('\n📖 Dictionary Item Details\n'));
+      console.log(`  ${chalk.gray('ID:')}            ${dictItem.dictId}`);
+      console.log(`  ${chalk.gray('Type ID:')}        ${dictItem.dictTypeId}`);
+      console.log(`  ${chalk.gray('Code:')}          ${dictItem.dictCode}`);
+      console.log(`  ${chalk.gray('Name:')}          ${dictItem.dictName}`);
+      console.log(`  ${chalk.gray('Value:')}          ${dictItem.dictValue}`);
+      console.log(`  ${chalk.gray('Sort Order:')}     ${dictItem.sortOrder}`);
+      console.log(`  ${chalk.gray('Status:')}         ${dictItem.statusFlag === 1 ? 'Enable' : 'Disable'}`);
+      if (dictItem.remark) {
+        console.log(`  ${chalk.gray('Remark:')}        ${dictItem.remark}`);
+      }
+      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/dicts/index.ts

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { createDictListCommand } from './list.js';
+import { createDictGetCommand } from './get.js';
+import { createDictDeleteCommand } from './delete.js';
+import { createDictCreateCommand } from './create.js';
+import { createDictUpdateCommand } from './update.js';
+
+export function createDictsCommand(): Command {
+  const dictsCommand = new Command('dicts');
+  dictsCommand.description('Manage dictionary items');
+
+  dictsCommand.addCommand(createDictListCommand());
+  dictsCommand.addCommand(createDictGetCommand());
+  dictsCommand.addCommand(createDictDeleteCommand());
+  dictsCommand.addCommand(createDictCreateCommand());
+  dictsCommand.addCommand(createDictUpdateCommand());
+
+  return dictsCommand;
+}

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

@@ -0,0 +1,114 @@
+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 { DictItem, DictStatusFlag } from '../../../types/dict.js';
+import { Environment } from '../../../types/index.js';
+
+export function createDictListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List dictionary items by type');
+
+  listCommand
+    .requiredOption('-t, --type-code <string>', 'Dict type code (e.g., ID_TYPE, sex)')
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--status <string>', 'Status filter (enable/disable)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const outputJson = options.json === true || process.argv.includes('--json');
+
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const typeCode = options.typeCode as string;
+      const page = parseInt(options.page as string, 10) - 1;
+      const size = parseInt(options.size as string, 10);
+
+      const params: {
+        dictTypeCode: string;
+        pageNo: number;
+        pageSize: number;
+        status?: DictStatusFlag;
+      } = { dictTypeCode: typeCode, pageNo: page, pageSize: size };
+
+      if (options.status !== undefined) {
+        const statusVal = (options.status as string).toLowerCase();
+        if (statusVal === 'enable' || statusVal === '1') {
+          params.status = 1;
+        } else if (statusVal === 'disable' || statusVal === '2') {
+          params.status = 2;
+        }
+      }
+
+      const response = await apiClient.listDictItems(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list dict items: ${response.error?.message || 'Unknown error'}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+        process.exit(1);
+      }
+
+      const records = (response.data as unknown as DictItem[]) || [];
+
+      if (!records || records.length === 0) {
+        if (outputJson) {
+          console.log(JSON.stringify({ success: true, data: { items: [] } }, null, 2));
+        } else {
+          console.log(chalk.bold('\n📖 Dict Items\n'));
+          console.log(chalk.gray('  No dict items found\n'));
+        }
+        return;
+      }
+
+      if (outputJson) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: {
+                items: records,
+              },
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+
+      console.log(chalk.bold('\n📖 Dict Items\n'));
+
+      const table = new Table({
+        head: [chalk.bold('ID'), chalk.bold('Code'), chalk.bold('Name'), chalk.bold('Sort'), chalk.bold('Status')],
+        colWidths: [14, 20, 30, 10, 10],
+        style: {
+          head: [],
+          border: [],
+        },
+      });
+
+      for (const item of records) {
+        const statusText = item.statusFlag === 1 ? chalk.green('Enable') : chalk.red('Disable');
+        table.push([
+          item.dictId,
+          item.dictCode || '-',
+          item.dictName || '-',
+          item.sortOrder?.toString() || '-',
+          statusText,
+        ]);
+      }
+
+      console.log(table.toString());
+      console.log();
+      console.log(chalk.gray(`  Total: ${records.length}`));
+      console.log();
+    });
+
+  return listCommand;
+}