@newpeak/barista-cli 0.1.8 → 0.1.10

package/src/commands/liberica/teams/projects/update.ts

@@ -0,0 +1,117 @@
+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 {
+  UpdateTeamProjectRequest,
+  ProjectStatus,
+  ProjectPriority,
+} from '../../../../types/team-project.js';
+
+export function createTeamProjectUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand
+    .description('Update team project information')
+    .argument('<project-id>', 'Project ID')
+    .option('--name <string>', 'Project name')
+    .option('--code <string>', 'Project code')
+    .option('--desc <string>', 'Project description')
+    .option('--status <string>', 'Project status: ACTIVE/INACTIVE/ARCHIVED')
+    .option('--priority <string>', 'Priority: LOW/MEDIUM/HIGH/URGENT')
+    .option('--start-date <string>', 'Start date (YYYY-MM-DD)')
+    .option('--end-date <string>', 'End date (YYYY-MM-DD)')
+    .option('--manager-id <string>', 'Manager user ID')
+    .option('--team-id <string>', 'Team ID')
+    .addOption(new Option('--env <string>').hideHelp())
+    .addOption(new Option('--tenant <string>').hideHelp())
+    .option('--dry-run', 'Preview without actual API call')
+    .option('--json', 'Output as JSON');
+
+  updateCommand.action(async (projectId: string, options: Record<string, unknown>) => {
+    const context = configManager.getCurrentContext();
+    const environment = context.environment as Environment;
+    const tenant = context.tenant;
+
+    const fields: Partial<UpdateTeamProjectRequest> = { teamProjectId: projectId };
+    if (options.name) fields.projectName = options.name as string;
+    if (options.code) fields.projectCode = options.code as string;
+    if (options.desc) fields.projectDesc = options.desc as string;
+    if (options.status) fields.projectStatus = options.status as ProjectStatus;
+    if (options.priority) fields.priority = options.priority as ProjectPriority;
+    if (options.startDate) fields.startDate = options.startDate as string;
+    if (options.endDate) fields.endDate = options.endDate as string;
+    if (options.managerId) fields.managerId = options.managerId as string;
+    if (options.teamId) fields.teamId = options.teamId as string;
+
+    const fieldsToUpdate = Object.keys(fields).filter((k) => k !== 'teamProjectId');
+    if (fieldsToUpdate.length === 0) {
+      console.error(
+        chalk.red(
+          '\n✗ No fields to update. Provide at least one option: --name, --code, --desc, --status, --priority, --start-date, --end-date, --manager-id, --team-id\n'
+        )
+      );
+      process.exit(1);
+    }
+
+    if (options.dryRun) {
+      console.log(chalk.bold('\n🔍 Dry-Run Mode: Preview update\n'));
+      console.log(chalk.gray('  Project ID: ') + chalk.white(projectId));
+      if (fields.projectName) console.log(chalk.gray('  Name: ') + chalk.white(fields.projectName));
+      if (fields.projectCode) console.log(chalk.gray('  Code: ') + chalk.white(fields.projectCode));
+      if (fields.projectDesc) console.log(chalk.gray('  Description: ') + chalk.white(fields.projectDesc));
+      if (fields.projectStatus) console.log(chalk.gray('  Status: ') + chalk.white(fields.projectStatus));
+      if (fields.priority) console.log(chalk.gray('  Priority: ') + chalk.white(fields.priority));
+      if (fields.startDate) console.log(chalk.gray('  Start Date: ') + chalk.white(fields.startDate));
+      if (fields.endDate) console.log(chalk.gray('  End Date: ') + chalk.white(fields.endDate));
+      if (fields.managerId) console.log(chalk.gray('  Manager ID: ') + chalk.white(fields.managerId));
+      if (fields.teamId) console.log(chalk.gray('  Team ID: ') + chalk.white(fields.teamId));
+      console.log();
+      console.log(chalk.yellow('  ⚠️  This is a dry-run. No API call was made.\n'));
+      process.exit(0);
+    }
+
+    try {
+      const response = await apiClient.updateTeamProject(
+        environment,
+        tenant,
+        fields as UpdateTeamProjectRequest
+      );
+
+      if (response.success) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+        } else {
+          console.log(chalk.green('\n✓ Team project 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/teams/tasks/create.ts

@@ -0,0 +1,102 @@
+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 { CreateTeamTaskRequest, TeamTask } from '../../../../types/team-task.js';
+import { Environment } from '../../../../types/index.js';
+
+export function createTeamTaskCreateCommand(): Command {
+  const createCommand = new Command('create');
+  createCommand.description('Create a new team task');
+
+  createCommand
+    .option('-t, --title <string>', 'Task title (required)')
+    .option('-d, --desc <string>', 'Task description')
+    .option('-p, --priority <string>', 'Priority (LOW/MEDIUM/HIGH/URGENT)', 'MEDIUM')
+    .option('-s, --status <string>', 'Status (OPEN/IN_PROGRESS/RESOLVED/CLOSED)', 'OPEN')
+    .option('-a, --assign-to <string>', 'Assignee (required)')
+    .option('--tags <string>', 'Tags (comma-separated)')
+    .option('--task-code <string>', 'Task code')
+    .option('--start-time <string>', 'Start time (ISO-8601)')
+    .option('--end-time <string>', 'End time (ISO-8601)')
+    .option('--completion-rate <number>', 'Completion rate (0-100)')
+    .option('--ref-id <string>', 'Reference ID')
+    .option('--dry-run', 'Preview without executing')
+    .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 taskTitle = options.title;
+      const assignTo = options.assignTo;
+
+      if (!taskTitle) {
+        console.error(chalk.red('\n✗ Task title is required. Use --title <title>'));
+        process.exit(1);
+      }
+
+      if (!assignTo) {
+        console.error(chalk.red('\n✗ Assignee is required. Use --assign-to <user>'));
+        process.exit(1);
+      }
+
+      const request: CreateTeamTaskRequest = {
+        taskTitle,
+        taskType: 'REQUIREMENT' as const,
+        taskDesc: options.desc,
+        projectId: '',
+        projectCode: '',
+        projectName: '',
+        assignTo: assignTo ? [assignTo] : undefined,
+        teamTaskStatus: options.status as any,
+        priority: options.priority as any,
+        tags: options.tags ? options.tags.split(',') : undefined,
+      };
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n🔍 Dry-Run Mode: The following team task will be created:\n'));
+        const previewTable = new Table({
+          head: ['Field', 'Value'],
+          colWidths: [20, 50],
+        });
+        previewTable.push(['Title', taskTitle]);
+        previewTable.push(['Description', options.desc || '-']);
+        previewTable.push(['Priority', options.priority]);
+        previewTable.push(['Status', options.status]);
+        previewTable.push(['Assignee', assignTo]);
+        previewTable.push(['Tags', options.tags || '-']);
+        previewTable.push(['Task Code', options.taskCode || '(auto-generated)']);
+        console.log(previewTable.toString());
+        console.log(chalk.yellow('\n⚠️  Add --confirm to execute or remove --dry-run\n'));
+        return;
+      }
+
+      const response = await apiClient.createTeamTask(environment, tenant, request);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to create team task: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      const task = response.data as TeamTask;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: task }, null, 2));
+        return;
+      }
+
+      console.log(chalk.green('\n✓ Team task created successfully\n'));
+      const table = new Table({
+        head: ['Field', 'Value'],
+        colWidths: [20, 50],
+      });
+      table.push(['Task ID', task.teamTaskId]);
+      table.push(['Task Code', task.teamTaskCode || '-']);
+      table.push(['Title', task.taskTitle]);
+      console.log(table.toString());
+    });
+
+  return createCommand;
+}

package/src/commands/liberica/teams/tasks/delete.ts

@@ -0,0 +1,92 @@
+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 { Environment } from '../../../../types/index.js';
+
+export function createTeamTaskDeleteCommand(): Command {
+  const deleteCommand = new Command('delete');
+  deleteCommand.description('Delete a team task');
+
+  deleteCommand
+    .option('-i, --task-id <string>', 'Task ID (required)')
+    .option('-f, --force', 'Skip confirmation')
+    .option('--dry-run', 'Preview without executing')
+    .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 taskId = options.taskId;
+
+      if (!taskId) {
+        console.error(chalk.red('\n✗ Task ID is required. Use --task-id <id>'));
+        process.exit(1);
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n🔍 Dry-Run Mode: The following team task will be deleted:\n'));
+        const previewTable = new Table({
+          head: ['Field', 'Value'],
+          colWidths: [20, 50],
+        });
+        previewTable.push(['Task ID', taskId]);
+        console.log(previewTable.toString());
+        console.log(chalk.yellow('\n⚠️  Add --confirm to execute or remove --dry-run\n'));
+        return;
+      }
+
+      if (!options.force) {
+        const readline = require('readline').createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        return new Promise<void>((resolve) => {
+          readline.question(
+            chalk.yellow(`\n⚠️  Are you sure you want to delete team task ${taskId}? (y/N): `),
+            async (answer: string) => {
+              readline.close();
+              if (answer.toLowerCase() !== 'y') {
+                console.log(chalk.gray('\nOperation cancelled.'));
+                process.exit(0);
+              }
+
+              const response = await apiClient.deleteTeamTask(environment, tenant, taskId);
+
+              if (!response.success) {
+                console.error(chalk.red(`\n✗ Failed to delete team task: ${response.error?.message || 'Unknown error'}`));
+                process.exit(1);
+              }
+
+              if (options.json) {
+                console.log(JSON.stringify({ success: true, message: 'Team task deleted successfully' }, null, 2));
+                return;
+              }
+
+              console.log(chalk.green('\n✓ Team task deleted successfully\n'));
+              resolve();
+            }
+          );
+        });
+      }
+
+      const response = await apiClient.deleteTeamTask(environment, tenant, taskId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to delete team task: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, message: 'Team task deleted successfully' }, null, 2));
+        return;
+      }
+
+      console.log(chalk.green('\n✓ Team task deleted successfully\n'));
+    });
+
+  return deleteCommand;
+}

package/src/commands/liberica/teams/tasks/get.ts

@@ -0,0 +1,64 @@
+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 { TeamTask } from '../../../../types/team-task.js';
+import { Environment } from '../../../../types/index.js';
+
+export function createTeamTaskGetCommand(): Command {
+  const getCommand = new Command('get');
+  getCommand.description('Get team task details');
+
+  getCommand
+    .option('-i, --task-id <string>', 'Task ID')
+    .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 taskId = options.taskId;
+
+      if (!taskId) {
+        console.error(chalk.red('\n✗ Task ID is required. Use --task-id <id>'));
+        process.exit(1);
+      }
+
+      const response = await apiClient.getTeamTask(environment, tenant, taskId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to get team task: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      const task = response.data as TeamTask;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: task }, null, 2));
+        return;
+      }
+
+      const table = new Table({
+        head: ['Field', 'Value'],
+        colWidths: [20, 50],
+      });
+
+      table.push(['Task ID', task.teamTaskId]);
+      table.push(['Task Code', task.teamTaskCode || '-']);
+      table.push(['Title', task.taskTitle]);
+      table.push(['Description', task.taskDesc || '-']);
+      table.push(['Type', task.taskType]);
+      table.push(['Status', task.teamTaskStatus]);
+      table.push(['Priority', task.priority]);
+      table.push(['Reporter', task.reporterName || '-']);
+      table.push(['Assignee', task.assignTo || '-']);
+      table.push(['Tags', task.tags || '-']);
+      table.push(['Reference ID', task.refId || '-']);
+
+      console.log(chalk.bold('\n📋 Team Task Details'));
+      console.log(table.toString());
+    });
+
+  return getCommand;
+}

package/src/commands/liberica/teams/tasks/index.ts

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { createTeamTaskListCommand } from './list.js';
+import { createTeamTaskGetCommand } from './get.js';
+import { createTeamTaskCreateCommand } from './create.js';
+import { createTeamTaskUpdateCommand } from './update.js';
+import { createTeamTaskDeleteCommand } from './delete.js';
+
+export function createTeamTasksCommand(): Command {
+  const tasksCommand = new Command('tasks');
+  tasksCommand.description('Manage team tasks');
+
+  tasksCommand.addCommand(createTeamTaskListCommand());
+  tasksCommand.addCommand(createTeamTaskGetCommand());
+  tasksCommand.addCommand(createTeamTaskCreateCommand());
+  tasksCommand.addCommand(createTeamTaskUpdateCommand());
+  tasksCommand.addCommand(createTeamTaskDeleteCommand());
+
+  return tasksCommand;
+}

package/src/commands/liberica/teams/tasks/list.ts

@@ -0,0 +1,102 @@
+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 {
+  TeamTaskQueryParams,
+  TeamTaskListResponse,
+  TeamTaskStatus,
+  TeamTaskPriority,
+} from '../../../../types/team-task.js';
+import { Environment } from '../../../../types/index.js';
+
+export function createTeamTaskListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List team tasks with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('-t, --title <string>', 'Filter by task title')
+    .option('--status <string>', 'Filter by status (OPEN/IN_PROGRESS/RESOLVED/CLOSED)')
+    .option('--priority <string>', 'Filter by priority (LOW/MEDIUM/HIGH/URGENT)')
+    .option('-a, --assign-to <string>', 'Filter by assignee')
+    .option('-c, --creator-name <string>', 'Filter by creator name')
+    .option('--task-code <string>', 'Filter by task code')
+    .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: TeamTaskQueryParams = {
+        pageNo: page,
+        pageSize: size,
+      };
+
+      if (options.title) {
+        params.taskTitle = options.title;
+      }
+      if (options.status) {
+        params.teamTaskStatus = options.status as TeamTaskStatus;
+      }
+      if (options.priority) {
+        params.priority = options.priority as TeamTaskPriority;
+      }
+      if (options.assignTo) {
+        params.assignTo = options.assignTo;
+      }
+      if (options.creatorName) {
+        params.reporterName = options.creatorName;
+      }
+      if (options.taskCode) {
+        params.teamTaskCode = options.taskCode;
+      }
+
+      const response = await apiClient.listTeamTasks(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to list team tasks: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      const data = response.data as TeamTaskListResponse;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data }, null, 2));
+        return;
+      }
+
+      if (!data.rows || data.rows.length === 0) {
+        console.log(chalk.yellow('\nNo team tasks found.'));
+        return;
+      }
+
+      const table = new Table({
+        head: ['Task ID', 'Task Code', 'Title', 'Status', 'Priority', 'Assignee', 'Creator'],
+        colWidths: [12, 12, 30, 12, 10, 15, 15],
+      });
+
+      data.rows.forEach((task) => {
+        table.push([
+          task.teamTaskId,
+          task.teamTaskCode || '-',
+          task.taskTitle,
+          task.teamTaskStatus,
+          task.priority,
+          task.assignTo || '-',
+          task.reporterName || '-',
+        ]);
+      });
+
+      console.log(chalk.bold('\n📋 Team Tasks List'));
+      console.log(table.toString());
+      console.log(chalk.gray(`\nTotal: ${data.totalRows} | Page: ${data.pageNo + 1}/${Math.ceil(data.totalRows / data.pageSize)}`));
+    });
+
+  return listCommand;
+}

package/src/commands/liberica/teams/tasks/update.ts

@@ -0,0 +1,122 @@
+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 { UpdateTeamTaskRequest, TeamTask } from '../../../../types/team-task.js';
+import { Environment } from '../../../../types/index.js';
+
+export function createTeamTaskUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand.description('Update a team task');
+
+  updateCommand
+    .option('-i, --task-id <string>', 'Task ID (required)')
+    .option('-t, --title <string>', 'Task title')
+    .option('-d, --desc <string>', 'Task description')
+    .option('-p, --priority <string>', 'Priority (LOW/MEDIUM/HIGH/URGENT)')
+    .option('-s, --status <string>', 'Status (OPEN/IN_PROGRESS/RESOLVED/CLOSED)')
+    .option('-a, --assign-to <string>', 'Assignee')
+    .option('--tags <string>', 'Tags (comma-separated)')
+    .option('--task-code <string>', 'Task code')
+    .option('--start-time <string>', 'Start time (ISO-8601)')
+    .option('--end-time <string>', 'End time (ISO-8601)')
+    .option('--completion-rate <number>', 'Completion rate (0-100)')
+    .option('--ref-id <string>', 'Reference ID')
+    .option('--dry-run', 'Preview without executing')
+    .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 taskId = options.taskId;
+
+      if (!taskId) {
+        console.error(chalk.red('\n✗ Task ID is required. Use --task-id <id>'));
+        process.exit(1);
+      }
+
+      const request: UpdateTeamTaskRequest = {
+        teamTaskId: taskId,
+      };
+
+      if (options.title) {
+        request.taskTitle = options.title;
+      }
+      if (options.desc) {
+        request.taskDesc = options.desc;
+      }
+      if (options.priority) {
+        request.priority = options.priority as any;
+      }
+      if (options.status) {
+        request.teamTaskStatus = options.status as any;
+      }
+      if (options.assignTo) {
+        request.assignTo = options.assignTo.split(',');
+      }
+      if (options.tags) {
+        request.tags = options.tags.split(',');
+      }
+      if (options.taskCode) {
+        request.taskCode = options.taskCode;
+      }
+      if (options.startTime) {
+        request.startTime = options.startTime;
+      }
+      if (options.endTime) {
+        request.endTime = options.endTime;
+      }
+      if (options.completionRate) {
+        request.completionRate = options.completionRate;
+      }
+      if (options.refId) {
+        request.refId = options.refId;
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n🔍 Dry-Run Mode: The following team task will be updated:\n'));
+        const previewTable = new Table({
+          head: ['Field', 'Value'],
+          colWidths: [20, 50],
+        });
+        previewTable.push(['Task ID', taskId]);
+        if (options.title) previewTable.push(['Title', options.title]);
+        if (options.desc) previewTable.push(['Description', options.desc]);
+        if (options.priority) previewTable.push(['Priority', options.priority]);
+        if (options.status) previewTable.push(['Status', options.status]);
+        if (options.assignTo) previewTable.push(['Assignee', options.assignTo]);
+        if (options.tags) previewTable.push(['Tags', options.tags]);
+        console.log(previewTable.toString());
+        console.log(chalk.yellow('\n⚠️  Add --confirm to execute or remove --dry-run\n'));
+        return;
+      }
+
+      const response = await apiClient.updateTeamTask(environment, tenant, request);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed to update team task: ${response.error?.message || 'Unknown error'}`));
+        process.exit(1);
+      }
+
+      const task = response.data as TeamTask;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: task }, null, 2));
+        return;
+      }
+
+      console.log(chalk.green('\n✓ Team task updated successfully\n'));
+      const table = new Table({
+        head: ['Field', 'Value'],
+        colWidths: [20, 50],
+      });
+      table.push(['Task ID', task.teamTaskId]);
+      table.push(['Task Code', task.teamTaskCode || '-']);
+      table.push(['Title', task.taskTitle]);
+      console.log(table.toString());
+    });
+
+  return updateCommand;
+}