@newpeak/barista-cli 0.1.10 → 0.1.12

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

@@ -1,118 +0,0 @@
-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 { DictType, DictStatusFlag } from '../../../types/dict.js';
-import { Environment } from '../../../types/index.js';
-
-export function createDictTypeListCommand(): Command {
-  const listCommand = new Command('list');
-  listCommand.description('List dictionary types with pagination');
-
-  listCommand
-    .option('-p, --page <number>', 'Page number', '1')
-    .option('-s, --size <number>', 'Page size', '20')
-    .option('--status <string>', 'Status filter (enable/disable)')
-    .option('--keyword <string>', 'Keyword search (dictTypeCode and dictTypeName)')
-    .option('--json', 'Output as JSON')
-    .action(async (options) => {
-      const context = configManager.getCurrentContext();
-      const environment = (options.env as Environment) || context.environment;
-      const tenant = options.tenant || context.tenant;
-
-      const page = parseInt(options.page as string, 10) - 1;
-      const size = parseInt(options.size as string, 10);
-
-      const params: {
-        pageNo: number;
-        pageSize: number;
-        status?: DictStatusFlag;
-        dictTypeCode?: string;
-        dictTypeName?: string;
-      } = { 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;
-        }
-      }
-
-      // Keyword searches both dictTypeCode and dictTypeName
-      if (options.keyword !== undefined) {
-        const keyword = options.keyword as string;
-        params.dictTypeCode = keyword;
-        params.dictTypeName = keyword;
-      }
-
-      const response = await apiClient.listDictTypes(environment, tenant, params);
-
-      if (!response.success) {
-        console.error(chalk.red(`\n✗ Failed to list dictionary types: ${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 DictType[]) || [];
-
-      if (!records || records.length === 0) {
-        if (options.json) {
-          console.log(JSON.stringify({ success: true, data: { items: [] } }, null, 2));
-        } else {
-          console.log(chalk.bold('\n📖 Dict Type List\n'));
-          console.log(chalk.gray('  No dictionary types found\n'));
-        }
-        return;
-      }
-
-      if (options.json) {
-        console.log(
-          JSON.stringify(
-            {
-              success: true,
-              data: {
-                items: records,
-              },
-            },
-            null,
-            2
-          )
-        );
-        return;
-      }
-
-      console.log(chalk.bold('\n📖 Dict Type List\n'));
-
-      const table = new Table({
-        head: [chalk.bold('ID'), chalk.bold('Code'), chalk.bold('Name'), chalk.bold('Status')],
-        colWidths: [14, 18, 35, 10],
-        style: {
-          head: [],
-          border: [],
-        },
-      });
-
-      for (const dictType of records) {
-        const statusText = dictType.statusFlag === 1 ? chalk.green('Enable') : chalk.red('Disable');
-        table.push([
-          dictType.dictTypeId,
-          dictType.dictTypeCode || '-',
-          dictType.dictTypeName || '-',
-          statusText,
-        ]);
-      }
-
-      console.log(table.toString());
-      console.log();
-      console.log(chalk.gray(`  Total: ${records.length}`));
-      console.log();
-    });
-
-  return listCommand;
-}

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

@@ -1,134 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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;
-}