trello-cli-unofficial 0.7.6 → 0.8.0

package/src/presentation/cli/CommandController.ts

@@ -1,9 +1,14 @@
+import type { OutputFormat } from '@/shared';
+
 import { AuthenticationService } from '@domain/services';
 import {
   FileConfigRepository,
   TrelloApiRepository,
 } from '@infrastructure/repositories';
 import { Command } from 'commander';
+
+import { t } from '@/i18n';
+import { ErrorHandler, OutputFormatter } from '@/shared';
 import { AuthController, BoardController, CardController } from './index';
 
 export class CommandController {
@@ -11,11 +16,13 @@ export class CommandController {
   private boardController!: BoardController;
   private cardController!: CardController;
   private program: Command;
+  private outputFormatter: OutputFormatter;
 
   constructor() {
     const configRepository = new FileConfigRepository();
     this.authController = new AuthController(configRepository);
     this.program = new Command();
+    this.outputFormatter = new OutputFormatter();
     this.setupCommands();
   }
 
@@ -29,78 +36,325 @@ export class CommandController {
       config.token!,
     );
 
-    this.boardController = new BoardController(trelloRepository);
+    this.boardController = new BoardController(
+      trelloRepository,
+      this.outputFormatter,
+    );
     this.cardController = new CardController(
       trelloRepository,
       this.boardController,
+      this.outputFormatter,
     );
   }
 
   private setupCommands(): void {
     this.program
       .name('trello-cli-unofficial')
-      .description('Unofficial Trello CLI using Power-Up authentication')
-      .version('1.0.0');
+      .description(t('commands.description'))
+      .version('1.0.0')
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .on('option:format', (format) => {
+        this.outputFormatter.setFormat(format as OutputFormat);
+      });
 
+    // Interactive mode
     this.program
       .command('interactive')
       .alias('i')
-      .description('Start interactive mode')
+      .description(t('commands.interactive.description'))
       .action(async () => {
         const configRepository = new FileConfigRepository();
         const cli = new (
           await import('./TrelloCliController')
-        ).TrelloCliController(configRepository);
+        ).TrelloCliController(configRepository, this.outputFormatter);
         await cli.run();
       });
 
+    // Setup command
     this.program
-      .command('boards')
-      .description('List all your Trello boards')
+      .command('setup')
+      .description(t('commands.setup.description'))
       .action(async () => {
+        await this.authController.setupToken();
+      });
+
+    // Boards subcommands
+    const boardsCmd = this.program
+      .command('boards')
+      .description(t('commands.boards.manage'));
+
+    boardsCmd
+      .command('list')
+      .description(t('commands.boards.description'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (options: { format?: string }) => {
         try {
           await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as OutputFormat);
+          }
           await this.boardController.showBoards();
+        } catch (error) {
+          ErrorHandler.handle(error, 'boards list');
+        }
+      });
+
+    boardsCmd
+      .command('show <boardId>')
+      .description(t('commands.boards.show.description'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (boardId: string, options: { format?: string }) => {
+        try {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as OutputFormat);
+          }
+          await this.boardController.showBoardDetails(boardId);
+        } catch (error) {
+          ErrorHandler.handle(error, 'boards show');
+        }
+      });
+
+    boardsCmd
+      .command('create <name>')
+      .description(t('commands.boards.create.description'))
+      .option(
+        '-d, --desc <description>',
+        t('commands.boards.create.descOption'),
+      )
+      .action(async (name: string, options: { desc?: string }) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.createBoard(name, options.desc);
         } catch (error) {
           console.error('❌ Erro:', (error as Error).message);
         }
       });
 
+    // Legacy boards command with deprecation warning
     this.program
-      .command('setup')
-      .description('Setup your Trello token')
+      .command('boards-legacy')
+      .description(t('commands.deprecated.boardsLegacyDescription'))
       .action(async () => {
-        await this.authController.setupToken();
+        console.warn(t('commands.deprecated.boardsLegacyWarning'));
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.showBoards();
+        } catch (error) {
+          console.error(
+            t('commands.deprecated.boardsLegacyError'),
+            (error as Error).message,
+          );
+        }
+      });
+
+    // Lists subcommands
+    const listsCmd = this.program
+      .command('lists')
+      .description(t('commands.lists.description'));
+
+    listsCmd
+      .command('list <boardId>')
+      .description(t('commands.lists.list.description'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (boardId: string, options: { format?: string }) => {
+        try {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as OutputFormat);
+          }
+          await this.boardController.showListsById(boardId);
+        } catch (error) {
+          ErrorHandler.handle(error, 'lists list');
+        }
+      });
+
+    listsCmd
+      .command('create <boardId> <name>')
+      .description(t('commands.lists.create.description'))
+      .action(async (boardId: string, name: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.createList(boardId, name);
+        } catch (error) {
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
+        }
+      });
+
+    listsCmd
+      .command('delete <listId>')
+      .description(t('commands.lists.delete.description'))
+      .action(async (listId: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.deleteList(listId);
+        } catch (error) {
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
+        }
+      });
+
+    listsCmd
+      .command('move <listId> <position>')
+      .description(t('commands.lists.move.description'))
+      .action(async (listId: string, position: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.moveList(
+            listId,
+            Number.parseInt(position),
+          );
+        } catch (error) {
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
+        }
       });
 
+    // Legacy lists command with deprecation warning
     this.program
-      .command('lists <boardName>')
-      .description('List all lists in a specific board')
+      .command('lists-legacy <boardName>')
+      .description(t('commands.deprecated.listsLegacyDescription'))
       .action(async (boardName: string) => {
+        console.warn(t('commands.deprecated.listsLegacyWarning'));
         try {
           await this.initializeTrelloControllers();
           await this.boardController.showLists(boardName);
         } catch (error) {
-          console.error('❌ Erro:', (error as Error).message);
+          console.error(
+            t('commands.deprecated.listsLegacyError'),
+            (error as Error).message,
+          );
+        }
+      });
+
+    // Cards subcommands
+    const cardsCmd = this.program
+      .command('cards')
+      .description(t('commands.cards.manage'));
+
+    cardsCmd
+      .command('list <listId>')
+      .description(t('commands.cards.list.description'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (listId: string, options: { format?: string }) => {
+        try {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as OutputFormat);
+          }
+          await this.boardController.showCardsByListId(listId);
+        } catch (error) {
+          ErrorHandler.handle(error, 'cards list');
+        }
+      });
+
+    cardsCmd
+      .command('create <listId> <name>')
+      .description(t('commands.cards.create.description'))
+      .option('-d, --desc <description>', t('commands.options.cardDescription'))
+      .action(
+        async (listId: string, name: string, options: { desc?: string }) => {
+          try {
+            await this.initializeTrelloControllers();
+            await this.cardController.createCardByListId(
+              listId,
+              name,
+              options.desc,
+            );
+          } catch (error) {
+            console.error(
+              t('commands.commandErrors.genericError'),
+              (error as Error).message,
+            );
+          }
+        },
+      );
+
+    cardsCmd
+      .command('move <cardId>')
+      .description(t('commands.cards.move.description'))
+      .requiredOption('-t, --to <listId>', t('commands.options.targetListId'))
+      .action(async (cardId: string, options: { to: string }) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.cardController.moveCardToList(cardId, options.to);
+        } catch (error) {
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
+        }
+      });
+
+    cardsCmd
+      .command('delete <cardId>')
+      .description(t('commands.cards.delete.description'))
+      .action(async (cardId: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.cardController.deleteCard(cardId);
+        } catch (error) {
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
         }
       });
 
+    cardsCmd
+      .command('update <cardId>')
+      .description(t('commands.cards.update.description'))
+      .option('-n, --name <name>', t('commands.options.newCardName'))
+      .option(
+        '-d, --desc <description>',
+        t('commands.options.newCardDescription'),
+      )
+      .action(
+        async (cardId: string, options: { name?: string; desc?: string }) => {
+          try {
+            await this.initializeTrelloControllers();
+            await this.cardController.updateCard(
+              cardId,
+              options.name,
+              options.desc,
+            );
+          } catch (error) {
+            console.error(
+              t('commands.commandErrors.genericError'),
+              (error as Error).message,
+            );
+          }
+        },
+      );
+
+    // Legacy commands with deprecation warnings
     this.program
-      .command('cards <boardName> <listName>')
-      .description('List all cards in a specific list')
+      .command('cards-legacy <boardName> <listName>')
+      .description(t('commands.deprecated.cardsLegacyDescription'))
       .action(async (boardName: string, listName: string) => {
+        console.warn(t('commands.deprecated.cardsLegacyWarning'));
         try {
           await this.initializeTrelloControllers();
           await this.boardController.showCards(boardName, listName);
         } catch (error) {
-          console.error('❌ Erro:', (error as Error).message);
+          console.error(
+            t('commands.deprecated.cardsLegacyError'),
+            (error as Error).message,
+          );
         }
       });
 
     this.program
-      .command('create-card <boardName> <listName> <cardName>')
-      .description('Create a new card in a specific board and list')
-      .option('-d, --desc <description>', 'Card description')
+      .command('create-card-legacy <boardName> <listName> <cardName>')
+      .description(t('commands.deprecated.createCardLegacyDescription'))
+      .option('-d, --desc <description>', t('commands.options.cardDescription'))
       .action(
         async (
           boardName: string,
@@ -108,6 +362,7 @@ export class CommandController {
           cardName: string,
           options: { desc?: string },
         ) => {
+          console.warn(t('commands.deprecated.createCardLegacyWarning'));
           try {
             await this.initializeTrelloControllers();
             await this.cardController.createCard(
@@ -117,32 +372,43 @@ export class CommandController {
               options.desc,
             );
           } catch (error) {
-            console.error('❌ Erro:', (error as Error).message);
+            console.error(
+              t('commands.commandErrors.genericError'),
+              (error as Error).message,
+            );
           }
         },
       );
 
     this.program
-      .command('move-card <cardId> <listName>')
-      .description('Move a card to a different list')
+      .command('move-card-legacy <cardId> <listName>')
+      .description(t('commands.deprecated.moveCardLegacyDescription'))
       .action(async (cardId: string, listName: string) => {
+        console.warn(t('commands.deprecated.moveCardLegacyWarning'));
         try {
           await this.initializeTrelloControllers();
           await this.cardController.moveCard(cardId, listName);
         } catch (error) {
-          console.error('❌ Erro:', (error as Error).message);
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
         }
       });
 
     this.program
-      .command('delete-card <cardId>')
-      .description('Delete a card by its ID')
+      .command('delete-card-legacy <cardId>')
+      .description(t('commands.deprecated.deleteCardLegacyDescription'))
       .action(async (cardId: string) => {
+        console.warn(t('commands.deprecated.deleteCardLegacyWarning'));
         try {
           await this.initializeTrelloControllers();
           await this.cardController.deleteCard(cardId);
         } catch (error) {
-          console.error('❌ Erro:', (error as Error).message);
+          console.error(
+            t('commands.commandErrors.genericError'),
+            (error as Error).message,
+          );
         }
       });
   }
@@ -153,7 +419,7 @@ export class CommandController {
       const configRepository = new FileConfigRepository();
       const cli = new (
         await import('./TrelloCliController')
-      ).TrelloCliController(configRepository);
+      ).TrelloCliController(configRepository, this.outputFormatter);
       await cli.run();
     } else {
       this.program.parse();

package/src/presentation/cli/ConfigController.ts

@@ -1,10 +1,11 @@
+import type { AuthController } from './AuthController';
 import { CONFIG_ACTIONS } from '@shared/types';
 
 import inquirer from 'inquirer';
 import { t } from '@/i18n';
 
 export class ConfigController {
-  constructor(private authController: { getConfig: () => Promise<unknown>; setupToken: () => Promise<void> }) {}
+  constructor(private authController: AuthController) {}
 
   async showConfigMenu(): Promise<void> {
     while (true) {
@@ -27,9 +28,9 @@ export class ConfigController {
           await this.authController.setupToken();
           break;
         case CONFIG_ACTIONS.VIEW:
-          const config = await this.authController.getConfig() as any;
+          const config = await this.authController.getConfig();
           console.log(t('menu.currentConfig'));
-          console.log(`API Key: ${config.apiKey}`);
+          console.log(`${t('menu.apiKey')} ${config.apiKey}`);
           const tokenStatus = config.hasValidToken()
             ? `✅ ${t('common.yes')}`
             : `❌ ${t('common.no')}`;

package/src/presentation/cli/TrelloCliController.ts

@@ -1,4 +1,5 @@
 import type { ConfigRepository } from '@domain/repositories';
+import type { OutputFormatter } from '@/shared';
 import { AuthenticationService } from '@domain/services';
 import { TrelloApiRepository } from '@infrastructure/repositories';
 import {
@@ -16,7 +17,10 @@ export class TrelloCliController {
   private configController!: ConfigController;
   private mainMenuController!: MainMenuController;
 
-  constructor(private configRepository: ConfigRepository) {
+  constructor(
+    private configRepository: ConfigRepository,
+    private outputFormatter: OutputFormatter,
+  ) {
     this.initializeControllers();
   }
 
@@ -33,10 +37,14 @@ export class TrelloCliController {
       config.token!,
     );
 
-    this.boardController = new BoardController(trelloRepository);
+    this.boardController = new BoardController(
+      trelloRepository,
+      this.outputFormatter,
+    );
     this.cardController = new CardController(
       trelloRepository,
       this.boardController,
+      this.outputFormatter,
     );
     this.configController = new ConfigController(this.authController);
     this.mainMenuController = new MainMenuController(