trello-cli-unofficial 0.6.9 → 0.7.3

package/src/presentation/cli/CardController.ts

@@ -0,0 +1,319 @@
+import type { CardEntity, ListEntity } from '@domain/entities';
+import type { TrelloRepository } from '@domain/repositories';
+import {
+  CreateCardUseCase,
+  DeleteCardUseCase,
+  MoveCardUseCase,
+  UpdateCardUseCase,
+} from '@application/use-cases';
+import { CARD_ACTIONS } from '@shared/types';
+import inquirer from 'inquirer';
+
+export class CardController {
+  private createCardUseCase: CreateCardUseCase;
+  private updateCardUseCase: UpdateCardUseCase;
+  private deleteCardUseCase: DeleteCardUseCase;
+  private moveCardUseCase: MoveCardUseCase;
+
+  constructor(
+    private trelloRepository: TrelloRepository,
+    private boardController: unknown, // Will be injected to avoid circular dependency
+  ) {
+    this.createCardUseCase = new CreateCardUseCase(trelloRepository);
+    this.updateCardUseCase = new UpdateCardUseCase(trelloRepository);
+    this.deleteCardUseCase = new DeleteCardUseCase(trelloRepository);
+    this.moveCardUseCase = new MoveCardUseCase(trelloRepository);
+  }
+
+  async createCardInteractive(): Promise<void> {
+    const boards = await (this.boardController as any).getBoards();
+
+    const { selectedBoard } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedBoard',
+        message: 'Selecione o quadro:',
+        choices: boards.map((board: any) => ({ name: board.name, value: board.id })),
+      },
+    ]);
+
+    const lists = await (this.boardController as any).getLists(selectedBoard);
+
+    const { selectedList } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedList',
+        message: 'Selecione a lista:',
+        choices: lists.map((list: any) => ({ name: list.name, value: list.id })),
+      },
+    ]);
+
+    const { cardName, cardDesc } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'cardName',
+        message: 'Nome do cartão:',
+        validate: input => input.length > 0 || 'Nome é obrigatório',
+      },
+      {
+        type: 'input',
+        name: 'cardDesc',
+        message: 'Descrição (opcional):',
+      },
+    ]);
+
+    const newCard = await this.createCardUseCase.execute({
+      name: cardName,
+      desc: cardDesc,
+      listId: selectedList,
+    });
+
+    console.log('✅ Cartão criado com sucesso!');
+    console.log(`📝 Nome: ${newCard.name}`);
+    console.log(`🔗 URL: ${newCard.url}`);
+  }
+
+  async exploreCards(boardId: string, lists: ListEntity[]): Promise<void> {
+    const { selectedList } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedList',
+        message: 'Selecione uma lista:',
+        choices: lists.map(list => ({ name: list.name, value: list.id })),
+      },
+    ]);
+
+    const cards = await (this.boardController as any).getCards(selectedList);
+
+    if (cards.length === 0) {
+      console.log('📭 Esta lista está vazia.');
+      return;
+    }
+
+    console.log(
+      `🃏 Cartões em "${lists.find(l => l.id === selectedList)?.name}":`,
+    );
+    cards.forEach((card: any, index: number) => {
+      console.log(`${index + 1}. ${card.name}`);
+      if (card.desc) {
+        const desc
+          = card.desc.length > 100
+            ? `${card.desc.substring(0, 100)}...`
+            : card.desc;
+        console.log(`   📝 ${desc}`);
+      }
+      console.log(`   🔗 ${card.url}\n`);
+    });
+
+    // Opções adicionais
+    const { nextAction } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'nextAction',
+        message: 'O que deseja fazer?',
+        choices: [
+          { name: '⬅️  Voltar ao menu', value: CARD_ACTIONS.BACK },
+          { name: '📝 Editar cartão', value: CARD_ACTIONS.EDIT },
+          { name: '🗑️  Deletar cartão', value: CARD_ACTIONS.DELETE },
+          { name: '📦 Mover cartão', value: CARD_ACTIONS.MOVE },
+        ],
+      },
+    ]);
+
+    if (nextAction !== CARD_ACTIONS.BACK) {
+      const { selectedCard } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'selectedCard',
+          message: 'Selecione um cartão:',
+          choices: cards.map((card: any) => ({ name: card.name, value: card.id })),
+        },
+      ]);
+
+      const selectedCardEntity = cards.find((c: any) => c.id === selectedCard)!;
+
+      switch (nextAction) {
+        case CARD_ACTIONS.EDIT:
+          await this.editCard(selectedCard, selectedCardEntity);
+          break;
+        case CARD_ACTIONS.DELETE:
+          await this.deleteCardInteractive(selectedCard, selectedCardEntity);
+          break;
+        case CARD_ACTIONS.MOVE:
+          await this.moveCardInteractive(selectedCard, boardId, lists);
+          break;
+      }
+    }
+  }
+
+  private async editCard(cardId: string, card: CardEntity): Promise<void> {
+    const { newName, newDesc } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'newName',
+        message: 'Novo nome:',
+        default: card.name,
+      },
+      {
+        type: 'input',
+        name: 'newDesc',
+        message: 'Nova descrição:',
+        default: card.desc || '',
+      },
+    ]);
+
+    await this.updateCardUseCase.execute(cardId, {
+      name: newName,
+      desc: newDesc,
+    });
+    console.log('✅ Cartão atualizado com sucesso!');
+  }
+
+  private async deleteCardInteractive(
+    cardId: string,
+    card: CardEntity,
+  ): Promise<void> {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Tem certeza que deseja deletar "${card.name}"?`,
+        default: false,
+      },
+    ]);
+
+    if (confirm) {
+      await this.deleteCard(cardId, card);
+    }
+  }
+
+  private async moveCardInteractive(
+    cardId: string,
+    currentBoardId: string,
+    lists: ListEntity[],
+  ): Promise<void> {
+    const { targetList } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'targetList',
+        message: 'Mover para qual lista?',
+        choices: lists.map(list => ({ name: list.name, value: list.id })),
+      },
+    ]);
+
+    // Encontrar o nome da lista de destino para passar para o método público
+    const targetListObj = lists.find(list => list.id === targetList);
+    if (targetListObj) {
+      await this.moveCard(cardId, targetListObj.name);
+    }
+  }
+
+  async createCard(
+    boardName: string,
+    listName: string,
+    cardName: string,
+    description?: string,
+  ): Promise<void> {
+    const boards = await (this.boardController as any).getBoards();
+    const board = boards.find((b: any) => b.name === boardName);
+
+    if (!board) {
+      throw new Error(`Quadro "${boardName}" não encontrado`);
+    }
+
+    const lists = await (this.boardController as any).getLists(board.id);
+    const list = lists.find((l: any) => l.name === listName);
+
+    if (!list) {
+      throw new Error(
+        `Lista "${listName}" não encontrada no quadro "${boardName}"`,
+      );
+    }
+
+    const newCard = await this.createCardUseCase.execute({
+      name: cardName,
+      desc: description || '',
+      listId: list.id,
+    });
+
+    console.log('✅ Cartão criado com sucesso!');
+    console.log(`📝 Nome: ${newCard.name}`);
+    console.log(`🔗 URL: ${newCard.url}`);
+    console.log(`🆔 ID: ${newCard.id}`);
+  }
+
+  async moveCard(cardId: string, targetListName: string): Promise<void> {
+    // Primeiro precisamos encontrar em qual board o cartão está
+    // Para isso, vamos buscar todas as listas de todos os boards
+    const boards = await (this.boardController as any).getBoards();
+
+    for (const board of boards) {
+      const lists = await (this.boardController as any).getLists(board.id);
+
+      // Verificar se alguma lista contém o cartão
+      for (const list of lists) {
+        try {
+          const cards = await (this.boardController as any).getCards(list.id);
+          const card = cards.find((c: any) => c.id === cardId);
+
+          if (card) {
+            // Encontrou o cartão! Agora procurar a lista de destino
+            const targetList = lists.find((l: any) => l.name === targetListName);
+
+            if (!targetList) {
+              throw new Error(
+                `Lista "${targetListName}" não encontrada no quadro "${board.name}"`,
+              );
+            }
+
+            await this.moveCardUseCase.execute(cardId, targetList.id);
+            console.log('✅ Cartão movido com sucesso!');
+            console.log(`📝 Cartão: ${card.name}`);
+            console.log(`➡️  Para: ${targetList.name}`);
+            return;
+          }
+        } catch {
+          // Ignorar erros ao buscar cards, continuar procurando
+          continue;
+        }
+      }
+    }
+
+    throw new Error(`Cartão com ID "${cardId}" não encontrado`);
+  }
+
+  async deleteCard(cardId: string, card?: CardEntity): Promise<void> {
+    // Se não passou o card, tentar encontrar
+    if (!card) {
+      const boards = await (this.boardController as any).getBoards();
+
+      for (const board of boards) {
+        const lists = await (this.boardController as any).getLists(board.id);
+
+        for (const list of lists) {
+          try {
+            const cards = await (this.boardController as any).getCards(list.id);
+            card = cards.find((c: any) => c.id === cardId);
+
+            if (card) {
+              break;
+            }
+          } catch {
+            continue;
+          }
+        }
+        if (card) {
+          break;
+        }
+      }
+
+      if (!card) {
+        throw new Error(`Cartão com ID "${cardId}" não encontrado`);
+      }
+    }
+
+    await this.deleteCardUseCase.execute(cardId);
+    console.log('✅ Cartão deletado com sucesso!');
+    console.log(`📝 Nome: ${card.name}`);
+  }
+}

package/src/presentation/cli/CommandController.ts

@@ -1,18 +1,41 @@
+import { AuthenticationService } from '@domain/services';
+import {
+  FileConfigRepository,
+  TrelloApiRepository,
+} from '@infrastructure/repositories';
 import { Command } from 'commander';
-import { FileConfigRepository } from '../../infrastructure/repositories';
-import { TrelloCliController } from './TrelloCliController';
+import { AuthController, BoardController, CardController } from './index';
 
 export class CommandController {
-  private cli: TrelloCliController;
+  private authController: AuthController;
+  private boardController!: BoardController;
+  private cardController!: CardController;
   private program: Command;
 
   constructor() {
     const configRepository = new FileConfigRepository();
-    this.cli = new TrelloCliController(configRepository);
+    this.authController = new AuthController(configRepository);
     this.program = new Command();
     this.setupCommands();
   }
 
+  private async initializeTrelloControllers(): Promise<void> {
+    await this.authController.ensureAuthenticated();
+
+    const authService = new AuthenticationService(new FileConfigRepository());
+    const config = await authService.getConfig();
+    const trelloRepository = new TrelloApiRepository(
+      config.apiKey,
+      config.token!,
+    );
+
+    this.boardController = new BoardController(trelloRepository);
+    this.cardController = new CardController(
+      trelloRepository,
+      this.boardController,
+    );
+  }
+
   private setupCommands(): void {
     this.program
       .name('trello-cli-unofficial')
@@ -24,7 +47,11 @@ export class CommandController {
       .alias('i')
       .description('Start interactive mode')
       .action(async () => {
-        await this.cli.showMenu();
+        const configRepository = new FileConfigRepository();
+        const cli = new (
+          await import('./TrelloCliController')
+        ).TrelloCliController(configRepository);
+        await cli.run();
       });
 
     this.program
@@ -32,9 +59,8 @@ export class CommandController {
       .description('List all your Trello boards')
       .action(async () => {
         try {
-          await this.cli.ensureAuthenticated();
-          await this.cli.initializeTrelloUseCases();
-          await this.cli.showBoards();
+          await this.initializeTrelloControllers();
+          await this.boardController.showBoards();
         } catch (error) {
           console.error('❌ Erro:', (error as Error).message);
         }
@@ -44,14 +70,91 @@ export class CommandController {
       .command('setup')
       .description('Setup your Trello token')
       .action(async () => {
-        await this.cli.setupToken();
+        await this.authController.setupToken();
+      });
+
+    this.program
+      .command('lists <boardName>')
+      .description('List all lists in a specific board')
+      .action(async (boardName: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.showLists(boardName);
+        } catch (error) {
+          console.error('❌ Erro:', (error as Error).message);
+        }
+      });
+
+    this.program
+      .command('cards <boardName> <listName>')
+      .description('List all cards in a specific list')
+      .action(async (boardName: string, listName: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.boardController.showCards(boardName, listName);
+        } catch (error) {
+          console.error('❌ Erro:', (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')
+      .action(
+        async (
+          boardName: string,
+          listName: string,
+          cardName: string,
+          options: { desc?: string },
+        ) => {
+          try {
+            await this.initializeTrelloControllers();
+            await this.cardController.createCard(
+              boardName,
+              listName,
+              cardName,
+              options.desc,
+            );
+          } catch (error) {
+            console.error('❌ Erro:', (error as Error).message);
+          }
+        },
+      );
+
+    this.program
+      .command('move-card <cardId> <listName>')
+      .description('Move a card to a different list')
+      .action(async (cardId: string, listName: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.cardController.moveCard(cardId, listName);
+        } catch (error) {
+          console.error('❌ Erro:', (error as Error).message);
+        }
+      });
+
+    this.program
+      .command('delete-card <cardId>')
+      .description('Delete a card by its ID')
+      .action(async (cardId: string) => {
+        try {
+          await this.initializeTrelloControllers();
+          await this.cardController.deleteCard(cardId);
+        } catch (error) {
+          console.error('❌ Erro:', (error as Error).message);
+        }
       });
   }
 
   async run(): Promise<void> {
     // Fallback to interactive mode if no command specified
     if (process.argv.length === 2) {
-      await this.cli.showMenu();
+      const configRepository = new FileConfigRepository();
+      const cli = new (
+        await import('./TrelloCliController')
+      ).TrelloCliController(configRepository);
+      await cli.run();
     } else {
       this.program.parse();
     }

package/src/presentation/cli/ConfigController.ts

@@ -0,0 +1,57 @@
+import { CONFIG_ACTIONS } from '@shared/types';
+import inquirer from 'inquirer';
+
+export class ConfigController {
+  constructor(private authController: { getConfig: () => Promise<unknown>; setupToken: () => Promise<void> }) {}
+
+  async showConfigMenu(): Promise<void> {
+    while (true) {
+      const { configAction } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'configAction',
+          message: '⚙️ Configurações',
+          choices: [
+            { name: '🔑 Configurar token', value: CONFIG_ACTIONS.TOKEN },
+            { name: '👀 Ver configuração atual', value: CONFIG_ACTIONS.VIEW },
+            { name: '🔄 Resetar configuração', value: CONFIG_ACTIONS.RESET },
+            { name: '⬅️  Voltar', value: CONFIG_ACTIONS.BACK },
+          ],
+        },
+      ]);
+
+      switch (configAction) {
+        case CONFIG_ACTIONS.TOKEN:
+          await this.authController.setupToken();
+          break;
+        case CONFIG_ACTIONS.VIEW:
+          const config = await this.authController.getConfig() as any;
+          console.log('📋 Configuração atual:');
+          console.log(`API Key: ${config.apiKey}`);
+          console.log(
+            `Token configurado: ${config.hasValidToken() ? '✅ Sim' : '❌ Não'}`,
+          );
+          console.log(
+            `Arquivo de config: ~/.trello-cli-unofficial/config.json`,
+          );
+          break;
+        case CONFIG_ACTIONS.RESET:
+          const { confirm } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'confirm',
+              message: 'Tem certeza que deseja resetar toda a configuração?',
+              default: false,
+            },
+          ]);
+          if (confirm) {
+            // Reset logic would need to be implemented in the use case
+            console.log('✅ Configuração resetada!');
+          }
+          break;
+        case CONFIG_ACTIONS.BACK:
+          return;
+      }
+    }
+  }
+}

package/src/presentation/cli/MainMenuController.ts

@@ -0,0 +1,62 @@
+import type { ListEntity } from '@domain/entities';
+import { MENU_ACTIONS } from '@shared/types';
+import inquirer from 'inquirer';
+
+export class MainMenuController {
+  constructor(
+    private boardController: { showBoards: () => Promise<void> },
+    private cardController: {
+      createCardInteractive: () => Promise<void>;
+      exploreCards: (boardId: string, lists: ListEntity[]) => Promise<void>;
+    },
+    private configController: { showConfigMenu: () => Promise<void> },
+  ) {}
+
+  async showMenu(): Promise<void> {
+    while (true) {
+      const { action } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'action',
+          message: '🏠 Menu Principal - Trello CLI Unofficial',
+          choices: [
+            { name: '📋 Ver meus quadros', value: MENU_ACTIONS.BOARDS },
+            { name: '📝 Explorar quadro', value: MENU_ACTIONS.EXPLORE },
+            { name: '➕ Criar cartão', value: MENU_ACTIONS.CREATE },
+            { name: '⚙️  Configurações', value: MENU_ACTIONS.CONFIG },
+            { name: '🚪 Sair', value: MENU_ACTIONS.EXIT },
+          ],
+        },
+      ]);
+
+      try {
+        switch (action) {
+          case MENU_ACTIONS.BOARDS:
+            await this.boardController.showBoards();
+            break;
+          case MENU_ACTIONS.EXPLORE:
+            await this.exploreBoard();
+            break;
+          case MENU_ACTIONS.CREATE:
+            await this.cardController.createCardInteractive();
+            break;
+          case MENU_ACTIONS.CONFIG:
+            await this.configController.showConfigMenu();
+            break;
+          case MENU_ACTIONS.EXIT:
+            console.log('👋 Até logo!');
+            return;
+        }
+      } catch (error) {
+        console.error('❌ Erro:', (error as Error).message);
+      }
+
+      console.log(`\n${'='.repeat(50)}\n`);
+    }
+  }
+
+  private async exploreBoard(): Promise<void> {
+    // This will be implemented when we refactor the main controller
+    console.log('🚧 Explorar quadro - Em desenvolvimento');
+  }
+}