@newpeak/barista-cli 0.1.0

package/src/commands/context.ts

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../core/config/manager.js';
+import { tokenManager } from '../core/auth/token-manager.js';
+import { Environment } from '../types/index.js';
+
+export function createContextCommand(): Command {
+  const contextCommand = new Command('context');
+  contextCommand.description('Manage CLI context (environment, service, tenant)');
+
+  contextCommand.action(async () => {
+    await contextCommand.help();
+  });
+
+  contextCommand
+    .command('show')
+    .description('Show current context')
+    .action(async () => {
+      const context = configManager.getCurrentContext();
+      const token = await tokenManager.getToken({
+        service: context.service,
+        environment: context.environment,
+        tenant: context.tenant,
+      });
+
+      console.log(chalk.bold('\n📋 Current Context\n'));
+      console.log(`  ${chalk.gray('Environment:')} ${chalk.green(context.environment)}`);
+      console.log(`  ${chalk.gray('Service:')} ${chalk.green(context.service)}`);
+      console.log(`  ${chalk.gray('Tenant:')} ${chalk.green(context.tenant)}`);
+      console.log(
+        `  ${chalk.gray('Token Status:')} ${token ? chalk.green('✓ Logged in') : chalk.red('✗ Not logged in')}`
+      );
+      console.log();
+    });
+
+  contextCommand
+    .command('use-env <environment>')
+    .description('Switch environment (dev|test|prod-cn|prod-jp)')
+    .action(async (env: string) => {
+      const validEnvs: Environment[] = ['dev', 'test', 'prod-cn', 'prod-jp'];
+      if (!validEnvs.includes(env as Environment)) {
+        console.error(chalk.red(`Invalid environment: ${env}`));
+        console.log(chalk.gray(`Valid environments: ${validEnvs.join(', ')}`));
+        process.exit(1);
+      }
+
+      await configManager.setEnvironment(env as Environment);
+      console.log(chalk.green(`✓ Environment set to ${env}`));
+    });
+
+  contextCommand
+    .command('use-tenant <tenant>')
+    .description('Switch tenant')
+    .action(async (tenant: string) => {
+      await configManager.setTenant(tenant);
+      console.log(chalk.green(`✓ Tenant set to ${tenant}`));
+    });
+
+  return contextCommand;
+}

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

@@ -0,0 +1,170 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../../../core/config/manager.js';
+import { tokenManager } from '../../../core/auth/token-manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createLibericaAuthCommand(): Command {
+  const authCommand = new Command('auth');
+  authCommand.description('Manage Liberica authentication');
+
+  authCommand.action(async () => {
+    await authCommand.help();
+  });
+
+  authCommand
+    .command('login')
+    .description('Login to Liberica')
+    .arguments('<env> [tenant] [username] [password]')
+    .option('--env <environment>', 'Environment (dev|test|prod-cn|prod-jp)')
+    .option('--tenant <tenant>', 'Tenant name')
+    .option('--username <username>', 'Username')
+    .option('--password <password>', 'Password')
+    .action(async (env: string, tenant: string, username: string, password: string, options: Record<string, any>) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || env || context.environment;
+      let resolvedTenant = options.tenant || tenant || context.tenant;
+
+      console.log(chalk.bold(`\n🔐 Login to Liberica (${environment})\n`));
+
+      if (!resolvedTenant) {
+        const { tenant: inputTenant } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'tenant',
+            message: 'Enter tenant name:',
+            validate: (input: string) => input.length > 0 || 'Tenant is required',
+          },
+        ]);
+        resolvedTenant = inputTenant;
+      }
+
+      let resolvedUsername = options.username || username;
+      let resolvedPassword = options.password || password;
+
+      if (!resolvedUsername) {
+        const { username: inputUsername } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'username',
+            message: 'Enter username:',
+            validate: (input: string) => input.length > 0 || 'Username is required',
+          },
+        ]);
+        resolvedUsername = inputUsername;
+      }
+
+      if (!resolvedPassword) {
+        const { password: inputPassword } = await inquirer.prompt([
+          {
+            type: 'password',
+            name: 'password',
+            message: 'Enter password:',
+            validate: (input: string) => input.length > 0 || 'Password is required',
+          },
+        ]);
+        resolvedPassword = inputPassword;
+      }
+
+      try {
+        const response = await apiClient.login('liberica', environment, resolvedTenant, resolvedUsername, resolvedPassword);
+
+        if (response.success && response.data) {
+          try {
+            await tokenManager.setToken(
+              {
+                service: 'liberica',
+                environment,
+                tenant: resolvedTenant,
+              },
+              response.data.token
+            );
+          } catch (keytarError) {
+            console.error(chalk.red(`\n✗ Failed to save token to keychain: ${keytarError instanceof Error ? keytarError.message : 'Unknown error'}`));
+            console.error(chalk.gray('  This may occur in headless environments without D-Bus/X11.'));
+            console.error(chalk.gray('  The login was successful but the token could not be persisted.\n'));
+            process.exit(1);
+          }
+
+          await configManager.setTenant(resolvedTenant);
+
+          console.log(chalk.green('\n✓ Login successful'));
+          if (response.data.expiresAt) {
+            console.log(chalk.gray(`  Token expires: ${response.data.expiresAt}`));
+          }
+          console.log();
+        } else {
+          console.error(chalk.red(`\n✗ Login 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) {
+        console.error(chalk.red(`\n✗ Login error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        process.exit(1);
+      }
+    });
+
+  authCommand
+    .command('status')
+    .description('Check Liberica authentication status')
+    .action(async () => {
+      const environments: Environment[] = ['dev', 'test', 'prod-cn', 'prod-jp'];
+      const context = configManager.getCurrentContext();
+
+      console.log(chalk.bold('\n🔐 Liberica Authentication Status\n'));
+
+      for (const env of environments) {
+        const token = await tokenManager.getToken({ service: 'liberica', environment: env, tenant: context.tenant });
+        const statusIcon = token ? chalk.green('✓') : chalk.red('✗');
+        const statusText = token ? 'Logged in' : 'Not logged in';
+        const tenantText = context.tenant ? ` (${context.tenant})` : '';
+        console.log(`  ${statusIcon} ${chalk.gray('liberica')}${tenantText} (${env}): ${statusText}`);
+      }
+      console.log();
+    });
+
+  authCommand
+    .command('logout')
+    .description('Logout from Liberica and clear token')
+    .option('--env <environment>', 'Environment (dev|test|prod-cn|prod-jp)')
+    .option('--all', 'Clear all Liberica tokens')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+
+      if (options.all) {
+        const allTokens = await tokenManager.findAllTokens();
+        for (const cred of allTokens) {
+          const parts = cred.account.split(':');
+          if (parts[0] === 'liberica') {
+            await tokenManager.deleteToken({
+              service: 'liberica',
+              environment: parts[1] as Environment,
+              tenant: parts[2],
+            });
+          }
+        }
+        console.log(chalk.green('\n✓ All Liberica tokens cleared\n'));
+      } else {
+        const environment = (options.env as Environment) || context.environment;
+
+        const deleted = await tokenManager.deleteToken({
+          service: 'liberica',
+          environment,
+          tenant: context.tenant,
+        });
+
+        if (deleted) {
+          console.log(chalk.green(`\n✓ Token cleared for Liberica (${environment})\n`));
+        } else {
+          console.log(chalk.gray(`\nNo token found for Liberica (${environment})\n`));
+        }
+      }
+    });
+
+  return authCommand;
+}

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

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { tokenManager } from '../../../core/auth/token-manager.js';
+
+export function createLibericaContextCommand(): Command {
+  const contextCommand = new Command('context');
+  contextCommand.description('Manage Liberica context (tenant, environment)');
+
+  contextCommand.action(async () => {
+    await contextCommand.help();
+  });
+
+  contextCommand
+    .command('show')
+    .description('Show current Liberica context')
+    .action(async () => {
+      const context = configManager.getCurrentContext();
+      const token = await tokenManager.getToken({
+        service: 'liberica',
+        environment: context.environment,
+        tenant: context.tenant,
+      });
+
+      console.log(chalk.bold('\n📋 Liberica Context\n'));
+      console.log(`  ${chalk.gray('Environment:')} ${chalk.green(context.environment)}`);
+      console.log(`  ${chalk.gray('Tenant:')} ${chalk.green(context.tenant)}`);
+      console.log(
+        `  ${chalk.gray('Auth Status:')} ${token ? chalk.green('✓ Logged in') : chalk.red('✗ Not logged in')}`
+      );
+      console.log();
+    });
+
+  contextCommand
+    .command('use-enterprise <tenant>')
+    .description('Switch Liberica tenant (enterprise)')
+    .action(async (tenant: string) => {
+      await configManager.setTenant(tenant);
+      console.log(chalk.green(`\n✓ Tenant set to ${tenant}\n`));
+    });
+
+  return contextCommand;
+}

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

@@ -0,0 +1,275 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { apiClient } from '../../../core/api/client.js';
+import { configManager } from '../../../core/config/manager.js';
+import { CreateEmployeeRequest } from '../../../types/employee.js';
+
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PHONE_REGEX = /^[\d\s\-()+]+$/;
+const DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+const SEX_REGEX = /^[MF]$/;
+
+function validateFields(data: Partial<CreateEmployeeRequest>): string | null {
+  if (data.employeeEmail && !EMAIL_REGEX.test(data.employeeEmail)) {
+    return 'Invalid email format. Please provide a valid email address.';
+  }
+  if (data.employeePhone && !PHONE_REGEX.test(data.employeePhone)) {
+    return 'Invalid phone format. Phone must contain only digits, spaces, hyphens, or parentheses.';
+  }
+  if (data.employeeJoinedDate && !DATE_REGEX.test(data.employeeJoinedDate)) {
+    return 'Invalid date format. Date must be in YYYY-MM-DD format.';
+  }
+  if (data.employeeSex && !SEX_REGEX.test(data.employeeSex)) {
+    return 'Invalid sex value. Must be M or F.';
+  }
+  return null;
+}
+
+function formatTable(data: CreateEmployeeRequest): string {
+  const lines: string[] = [];
+  lines.push(`  ${chalk.gray('Name:')}         ${data.employeeName}`);
+  lines.push(`  ${chalk.gray('Employee No:')}   ${data.employeeNo}`);
+  if (data.employeeCode) lines.push(`  ${chalk.gray('Code:')}         ${data.employeeCode}`);
+  if (data.employeePhone) lines.push(`  ${chalk.gray('Phone:')}        ${data.employeePhone}`);
+  if (data.employeeEmail) lines.push(`  ${chalk.gray('Email:')}        ${data.employeeEmail}`);
+  if (data.employeeSex) lines.push(`  ${chalk.gray('Sex:')}          ${data.employeeSex}`);
+  if (data.organizationId) lines.push(`  ${chalk.gray('Org ID:')}       ${data.organizationId}`);
+  if (data.positionId) lines.push(`  ${chalk.gray('Position ID:')}   ${data.positionId}`);
+  if (data.employeeJoinedDate) lines.push(`  ${chalk.gray('Joined Date:')} ${data.employeeJoinedDate}`);
+  return lines.join('\n');
+}
+
+export function createEmployeeCreateCommand(): Command {
+  const cmd = new Command('create');
+  cmd.description('Create a new employee');
+
+  cmd
+    .option('-n, --name <name>', 'Employee name (required)')
+    .option('-c, --code <code>', 'Employee code (optional, auto-generated if empty)')
+    .option('-p, --phone <phone>', 'Phone number')
+    .option('-e, --email <email>', 'Email address')
+    .option('-s, --sex <sex>', 'Sex (M or F)')
+    .option('--org <name>', 'Organization name')
+    .option('--position <name>', 'Position name')
+    .option('-d, --joined-date <date>', 'Joined date (YYYY-MM-DD)')
+    .option('--no <no>', 'Employee number (required)')
+    .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 name = opts.name as string | undefined;
+    let no = (opts.no as string | undefined) || (opts['no'] as string | undefined);
+    const code = opts.code as string | undefined;
+    const phone = opts.phone as string | undefined;
+    const email = opts.email as string | undefined;
+    const sex = opts.sex as string | undefined;
+    const orgName = opts.org as string | undefined;
+    const positionName = opts.position as string | undefined;
+    const joinedDate = opts.joinedDate as string | undefined;
+    const dryRun = opts.dryRun === true;
+    const jsonOutput = opts.json === true;
+
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'inputName',
+          message: 'Enter employee name:',
+          validate: (input: string) => input.trim().length > 0 || 'Employee name is required',
+        },
+      ]);
+      name = inputName;
+    }
+
+    if (!no) {
+      const { inputNo } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'inputNo',
+          message: 'Enter employee number:',
+          validate: (input: string) => input.trim().length > 0 || 'Employee number is required',
+        },
+      ]);
+      no = inputNo;
+    }
+
+    let resolvedCode = code;
+    if (!resolvedCode) {
+      const codeResponse = await apiClient.getCodeByType(context.environment, context.tenant, 'TenantEmployeeCode');
+      if (codeResponse.success && codeResponse.data) {
+        resolvedCode = codeResponse.data;
+      }
+    }
+
+    let resolvedOrgId: string | undefined;
+    if (orgName) {
+      const orgResponse = await apiClient.getOrgListName(context.environment, context.tenant);
+      if (!orgResponse.success || !orgResponse.data) {
+        const errMsg = orgResponse.error?.message || 'Failed to fetch organization list';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: orgResponse.error?.code || 'FETCH_ORG_ERROR', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+      const found = orgResponse.data.find((o) => o.name === orgName);
+      if (!found) {
+        const errMsg = `Organization '${orgName}' not found`;
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'ORG_NOT_FOUND', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+      resolvedOrgId = found.id;
+    }
+
+    let resolvedPositionId: string | undefined;
+    if (positionName) {
+      const posResponse = await apiClient.listPositions(context.environment, context.tenant);
+      if (!posResponse.success || !posResponse.data) {
+        const errMsg = posResponse.error?.message || 'Failed to fetch position list';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: posResponse.error?.code || 'FETCH_POSITION_ERROR', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+      const found = posResponse.data.find((p) => p.name === positionName);
+      if (!found) {
+        const errMsg = `Position '${positionName}' not found`;
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'POSITION_NOT_FOUND', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+      resolvedPositionId = found.id;
+    }
+
+    const data: CreateEmployeeRequest = {
+      employeeName: name!,
+      employeeNo: no!,
+      employeeCode: resolvedCode,
+      employeePhone: phone,
+      employeeEmail: email,
+      employeeSex: sex as 'M' | 'F' | undefined,
+      organizationId: resolvedOrgId,
+      positionId: resolvedPositionId,
+      employeeJoinedDate: joinedDate,
+    };
+
+    const validationError = validateFields(data);
+    if (validationError) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: 'VALIDATION_ERROR', message: validationError } }));
+      } else {
+        console.error(chalk.red(`\n✗ Validation error: ${validationError}\n`));
+      }
+      process.exit(1);
+    }
+
+    if (dryRun) {
+      if (jsonOutput) {
+        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('  Employee to be created:');
+        console.log(formatTable(data));
+        console.log();
+      }
+      return;
+    }
+
+    const requestData: CreateEmployeeRequest = {
+      employeeName: data.employeeName,
+      employeeNo: data.employeeNo,
+      employeeCode: data.employeeCode,
+      employeePhone: data.employeePhone,
+      employeeEmail: data.employeeEmail,
+      employeeSex: data.employeeSex,
+      organizationId: data.organizationId,
+      positionId: data.positionId,
+      employeeJoinedDate: data.employeeJoinedDate,
+    };
+
+    if (!jsonOutput) {
+      console.log(chalk.bold('\n📝 Creating Employee\n'));
+    }
+
+    const response = await apiClient.createEmployee(context.environment, context.tenant, requestData);
+
+    if (!response.success) {
+      const errorMsg = response.error?.message || 'Failed to create employee';
+      const errorCode = response.error?.code || 'CREATE_EMPLOYEE_ERROR';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ Failed to create employee: ${errorMsg}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+      }
+      process.exit(1);
+    }
+
+    if (response.success) {
+      const emp = response.data as {
+        employeeId?: number;
+        employeeCode?: string;
+        employeeName?: string;
+        employeeNo?: string;
+        employeePhone?: string;
+        employeeEmail?: string;
+        employeeSex?: string;
+        organizationId?: number;
+        orgName?: string;
+        positionId?: string;
+        positionName?: string;
+        statusFlag?: number;
+        createTime?: string;
+      } | undefined;
+
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, data: emp }));
+      } else {
+        console.log(chalk.green('✓ Employee created successfully\n'));
+        if (emp?.employeeId) console.log(`  ${chalk.gray('Employee ID:')}  ${chalk.green(String(emp.employeeId))}`);
+        if (emp?.employeeName) console.log(`  ${chalk.gray('Name:')}         ${emp.employeeName}`);
+        if (emp?.employeeNo) console.log(`  ${chalk.gray('Employee No:')} ${emp.employeeNo}`);
+        if (emp?.employeeCode) console.log(`  ${chalk.gray('Code:')}         ${emp.employeeCode}`);
+        if (emp?.orgName) console.log(`  ${chalk.gray('Organization:')} ${emp.orgName}`);
+        if (emp?.positionName) console.log(`  ${chalk.gray('Position:')}    ${emp.positionName}`);
+        if (emp?.statusFlag !== undefined) {
+          const statusText = emp.statusFlag === 1 ? 'Enabled' : 'Disabled';
+          console.log(`  ${chalk.gray('Status:')}       ${chalk.green(statusText)}`);
+        }
+        console.log();
+      }
+    } else {
+      const errorMsg = response.error?.message || 'Failed to create employee';
+      const errorCode = response.error?.code || 'CREATE_EMPLOYEE_ERROR';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ Failed to create employee: ${errorMsg}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+      }
+      process.exit(1);
+    }
+  });
+
+  return cmd;
+}

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

@@ -0,0 +1,122 @@
+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 { Environment } from '../../../types/index.js';
+import { Employee } from '../../../types/employee.js';
+
+export function createEmployeeDeleteCommand(): Command {
+  const deleteCommand = new Command('delete');
+  deleteCommand
+    .description('Delete an employee')
+    .argument('<id>', 'Employee ID')
+    .option('--force', 'Skip confirmation prompt')
+    .option('--dry-run', 'Preview the operation without executing')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+      const jsonOutput = options.json === true;
+
+      const employeeId = id;
+
+      if (!jsonOutput) {
+        console.log(chalk.bold(`\n🗑️  Delete Employee (${environment})\n`));
+        console.log(chalk.gray(`  Employee ID: ${employeeId}`));
+      }
+
+      if (options.dryRun) {
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: true, dryRun: true, employeeId }));
+        } else {
+          console.log(chalk.cyan('\n🔍 Dry-Run Mode: No actual API call will be made\n'));
+          console.log(chalk.gray('  This operation will delete the employee.'));
+          console.log();
+        }
+        return;
+      }
+
+      let employee: Employee | undefined;
+      try {
+        const employeeResponse = await apiClient.getEmployee(environment, tenant, employeeId);
+        if (!employeeResponse.success || !employeeResponse.data) {
+          const errMsg = `Employee not found: ${employeeId}`;
+          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);
+        }
+        employee = employeeResponse.data as Employee;
+      } 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 employee: ${errMsg}` } }));
+        } else {
+          console.error(chalk.red(`\n✗ Failed to fetch employee: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      if (!options.force) {
+        if (!jsonOutput) {
+          console.log(chalk.gray(`  Name: ${employee.employeeName}`));
+          console.log(chalk.gray(`  Code: ${employee.employeeNo}`));
+        }
+
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Delete employee "${employee.employeeName}"? This action cannot be undone.`,
+            default: false,
+          },
+        ]);
+
+        if (!confirm) {
+          if (!jsonOutput) {
+            console.log(chalk.gray('\n  Operation cancelled.\n'));
+          }
+          process.exit(0);
+        }
+      }
+
+      try {
+        const response = await apiClient.deleteEmployee(environment, tenant, employeeId);
+
+        if (response.success) {
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, employeeId, name: employee.employeeName }));
+          } else {
+            console.log(chalk.green(`\n✓ Employee "${employee.employeeName}" (ID: ${employeeId}) 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 employee: ${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;
+}