@newpeak/barista-cli 0.1.8 → 0.1.10

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

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

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

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

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

@@ -0,0 +1,157 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { MouldEntityListResponse, MouldStatus } from '../../../types/mould.js';
+
+const VALID_STATUSES = ['FINE', 'REPAIR', 'SCRAP'] as const;
+
+export function createMouldListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List mould entities with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--status <status>', `Mould status filter (${VALID_STATUSES.join('|')})`)
+    .option('--material-code <code>', 'Material code filter')
+    .option('--material-name <name>', 'Material name filter (fuzzy)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const tenant = context.tenant;
+      const environment = context.environment;
+
+      const page = parseInt(options.page as string, 10);
+      const size = parseInt(options.size as string, 10);
+
+      const params: {
+        pageNo: number;
+        pageSize: number;
+        mouldStatus?: MouldStatus;
+        materialCode?: string;
+        materialName?: string;
+      } = { pageNo: page, pageSize: size };
+
+      if (options.status !== undefined) {
+        const status = options.status as MouldStatus;
+        if (VALID_STATUSES.includes(status)) {
+          params.mouldStatus = status;
+        }
+      }
+
+      if (options.materialCode !== undefined) {
+        params.materialCode = options.materialCode as string;
+      }
+
+      if (options.materialName !== undefined) {
+        params.materialName = options.materialName as string;
+      }
+
+      const response = await apiClient.listMouldEntities(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list moulds: ${response.error?.message || 'Unknown error'}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+        process.exit(1);
+      }
+
+      const data = response.data as MouldEntityListResponse | null;
+
+      if (!data) {
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { success: true, data: { rows: [], pagination: { pageNo: 0, pageSize: 20, totalRows: 0 } } },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log(chalk.bold('\n📋 Mould List\n'));
+          console.log(chalk.gray('  No moulds found\n'));
+        }
+        return;
+      }
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              data: {
+                rows: data.rows || [],
+                pagination: {
+                  pageNo: data.pageNo,
+                  pageSize: data.pageSize,
+                  totalRows: data.totalRows,
+                },
+              },
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+
+      const records = data.rows || [];
+
+      if (records.length === 0) {
+        console.log(chalk.bold('\n📋 Mould List\n'));
+        console.log(chalk.gray('  No moulds found\n'));
+        return;
+      }
+
+      console.log(chalk.bold('\n📋 Mould List\n'));
+
+      const table = new Table({
+        head: [
+          chalk.bold('Code'),
+          chalk.bold('Material'),
+          chalk.bold('Type'),
+          chalk.bold('Status'),
+          chalk.bold('Warehouse'),
+          chalk.bold('Produced'),
+        ],
+        colWidths: [16, 20, 14, 10, 14, 12],
+        style: {
+          head: [],
+          border: [],
+        },
+      });
+
+      for (const mould of records) {
+        const statusText =
+          mould.mouldStatus === 'FINE'
+            ? chalk.green('FINE')
+            : mould.mouldStatus === 'REPAIR'
+              ? chalk.yellow('REPAIR')
+              : chalk.red('SCRAP');
+
+        table.push([
+          mould.mouldEntityCode || '-',
+          mould.materialName || '-',
+          mould.mouldType || '-',
+          statusText,
+          mould.currentWarehouseCode || '-',
+          mould.producedDate || '-',
+        ]);
+      }
+
+      console.log(table.toString());
+      console.log();
+      console.log(
+        chalk.gray(
+          `  Total: ${data.totalRows} | Page: ${data.pageNo + 1} / ${Math.ceil(data.totalRows / data.pageSize) || 1} | Size: ${data.pageSize}`
+        )
+      );
+      console.log();
+    });
+
+  return listCommand;
+}

package/src/commands/liberica/mould/set-status.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { MouldStatus, MouldEntitySetStatusRequest } from '../../../types/mould.js';
+
+const VALID_STATUSES: MouldStatus[] = ['FINE', 'REPAIR', 'SCRAP'];
+
+export function createMouldSetStatusCommand(): Command {
+  const cmd = new Command('set-status');
+  cmd.description('Set mould status (FINE | REPAIR | SCRAP)');
+
+  cmd
+    .argument('<mouldEntityId>', 'Mould entity ID')
+    .argument('<status>', 'New status (FINE, REPAIR, or SCRAP)')
+    .option('--remark <remark>', 'Remark for status change')
+    .option('--json', 'Output as JSON')
+    .action(async (mouldEntityId: string, status: string, options: { remark?: string; json?: boolean }) => {
+      const context = configManager.getCurrentContext();
+      const tenant = context.tenant;
+      const environment = context.environment;
+
+      const mouldStatus = status.toUpperCase() as MouldStatus;
+      if (!VALID_STATUSES.includes(mouldStatus)) {
+        const errMsg = `Invalid status value: ${status}. Must be one of: ${VALID_STATUSES.join(', ')}`;
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { code: 'INVALID_STATUS', message: errMsg },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      const request: MouldEntitySetStatusRequest = {
+        mouldEntityId,
+        mouldStatus,
+        remark: options.remark,
+      };
+
+      if (!options.json) {
+        console.log(chalk.bold('\n🔧 Set Mould Status\n'));
+        console.log(`  ${chalk.gray('Mould ID:')}   ${mouldEntityId}`);
+        console.log(`  ${chalk.gray('New Status:')} ${mouldStatus}`);
+        if (options.remark) {
+          console.log(`  ${chalk.gray('Remark:')}    ${options.remark}`);
+        }
+        console.log();
+      }
+
+      const response = await apiClient.setMouldStatus(environment, tenant, request);
+
+      if (!response.success) {
+        const errorMsg = response.error?.message || 'Failed to set mould status';
+        const errorCode = response.error?.code || 'SET_MOULD_STATUS_ERROR';
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { code: errorCode, message: errorMsg },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ Failed to set mould status: ${errorMsg}`));
+          if (response.error?.code) {
+            console.error(chalk.gray(`  Error code: ${response.error.code}`));
+          }
+          console.error();
+        }
+        process.exit(1);
+      }
+
+      const data = response.data as { mouldEntityId?: string; mouldEntityCode?: string; mouldName?: string; mouldStatus?: string } | undefined;
+
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            success: true,
+            data: {
+              mouldId: data?.mouldEntityId || mouldEntityId,
+              mouldName: data?.mouldName,
+              currentStatus: data?.mouldStatus || mouldStatus,
+              remark: options.remark,
+            },
+          })
+        );
+      } else {
+        console.log(chalk.green(`✓ Mould status set to ${mouldStatus}`));
+        console.log();
+      }
+    });
+
+  return cmd;
+}

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/commands/liberica/teams/index.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { createTeamIssuesCommand } from './issues/index.js';
+import { createTeamProjectsCommand } from './projects/index.js';
+import { createTeamTasksCommand } from './tasks/index.js';
+import { createTeamWorkLogsCommand } from './work-logs/index.js';
+
+export function createTeamsCommand(): Command {
+  const teamsCommand = new Command('teams');
+  teamsCommand.description('Manage teams and issues');
+
+  teamsCommand.addCommand(createTeamIssuesCommand());
+  teamsCommand.addCommand(createTeamProjectsCommand());
+  teamsCommand.addCommand(createTeamTasksCommand());
+  teamsCommand.addCommand(createTeamWorkLogsCommand());
+
+  return teamsCommand;
+}

package/src/commands/liberica/teams/issues/close.ts

@@ -0,0 +1,104 @@
+import { Command, Option } 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 { UpdateTeamIssueRequest } from '../../../../types/team-issue.js';
+
+export function createTeamIssueCloseCommand(): Command {
+  const closeCommand = new Command('close');
+  closeCommand
+    .description('Close a team issue (sets status to CLOSED)')
+    .argument('<issue-id>', 'Issue ID')
+    .addOption(new Option('--env <string>').hideHelp())
+    .addOption(new Option('--tenant <string>').hideHelp())
+    .option('--json', 'Output as JSON');
+
+  closeCommand.action(async (issueId: string, options: Record<string, unknown>) => {
+    const context = configManager.getCurrentContext();
+    const environment = context.environment as Environment;
+    const tenant = context.tenant;
+
+    if (!issueId || issueId.trim() === '') {
+      console.error(chalk.red('\n✗ Issue ID is required\n'));
+      process.exit(1);
+    }
+
+    // Fetch the issue first to get all required fields
+    let existingIssue: Record<string, unknown> | null = null;
+    try {
+      const getResponse = await apiClient.getTeamIssue(environment, tenant, issueId);
+      if (!getResponse.success || !getResponse.data) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: getResponse.error }, null, 2));
+        } else {
+          console.error(chalk.red(`\n✗ Issue not found: ${getResponse.error?.message || 'Unknown error'}\n`));
+        }
+        process.exit(1);
+      }
+      existingIssue = getResponse.data as unknown as Record<string, unknown>;
+    } catch (error) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: { message: error instanceof Error ? error.message : 'Unknown error' } }, null, 2));
+      } else {
+        console.error(chalk.red(`\n✗ Error fetching issue: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+      }
+      process.exit(1);
+    }
+
+    const request: UpdateTeamIssueRequest = {
+      teamIssueId: issueId,
+      issueTitle: existingIssue.issueTitle as string,
+      issueDesc: existingIssue.issueDesc as string,
+      issueType: existingIssue.issueType as 'BUG' | 'REQUIREMENT' | 'QUESTION',
+      projectId: existingIssue.projectId as string,
+      projectCode: existingIssue.projectCode as string,
+      projectName: existingIssue.projectName as string,
+      reporterName: existingIssue.reporterName as string,
+      reporterEmail: existingIssue.reporterEmail as string,
+      priority: existingIssue.priority as 'LOW' | 'MEDIUM' | 'HIGH' | 'URGENT',
+      teamIssueStatus: 'CLOSED',
+      assignTo: existingIssue.assignTo as string[],
+      tags: existingIssue.tags as string[] | undefined,
+    };
+
+    try {
+      const response = await apiClient.updateTeamIssue(environment, tenant, request);
+
+      if (response.success) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+        } else {
+          console.log(chalk.green(`\n✓ Issue ${issueId} closed successfully\n`));
+        }
+      } else {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: response.error }, null, 2));
+        } else {
+          console.error(chalk.red(`\n✗ Close 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 closeCommand;
+}