trello-cli-unofficial 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.15.0](https://github.com/JaegerCaiser/trello-cli-unofficial/compare/v0.14.0...v0.15.0) (2026-04-05)
+
+
+### Features
+
+* inclui comandos faltantes de checklist ([5479ea0](https://github.com/JaegerCaiser/trello-cli-unofficial/commit/5479ea09d7349a76df5826414b9ba12a5ec3c40f))
+
 # [0.14.0](https://github.com/JaegerCaiser/trello-cli-unofficial/compare/v0.13.14...v0.14.0) (2026-04-04)
 
 

package/dist/main.js

@@ -2973,12 +2973,20 @@ var require_en = __commonJS((exports, module) => {
       created: '\u2705 Checklist "{{name}}" created successfully!',
       checklistId: "\uD83C\uDD94 ID: {{id}}",
       checklistCard: "\uD83D\uDCCB Card ID: {{idCard}}",
+      deleted: "\u2705 Checklist deleted successfully!",
+      renamed: '\u2705 Checklist renamed to "{{name}}" successfully!',
       itemAdded: '\u2705 Item "{{name}}" added to checklist successfully!',
+      itemDeleted: "\u2705 Checklist item deleted successfully!",
+      itemRenamed: '\u2705 Item renamed to "{{name}}" successfully!',
+      itemChecked: '\u2705 Item "{{name}}" marked as complete!',
+      itemUnchecked: '\u2705 Item "{{name}}" marked as incomplete!',
       itemId: "\uD83C\uDD94 ID: {{id}}",
       itemState: "\uD83D\uDCCC State: {{state}}",
+      forceRequired: "\u26A0\uFE0F  This operation is destructive. Add --force to confirm.",
       validation: {
         requiredName: "Checklist name is required",
-        requiredItemName: "Item name is required"
+        requiredItemName: "Item name is required",
+        requiredItemId: "Item ID is required"
       }
     },
     errors: {
@@ -3134,11 +3142,37 @@ var require_en = __commonJS((exports, module) => {
           description: "Create a checklist on a card",
           nameOption: "Checklist name"
         },
+        delete: {
+          description: "Delete a checklist",
+          forceOption: "Skip confirmation"
+        },
+        rename: {
+          description: "Rename a checklist",
+          nameOption: "New checklist name"
+        },
         item: {
           description: "Manage checklist items",
           add: {
             description: "Add an item to a checklist",
             nameOption: "Item name"
+          },
+          delete: {
+            description: "Delete an item from a checklist",
+            itemOption: "Item ID to delete",
+            forceOption: "Skip confirmation"
+          },
+          rename: {
+            description: "Rename an item of a checklist",
+            itemOption: "Item ID to rename",
+            nameOption: "New item name"
+          },
+          check: {
+            description: "Mark a checklist item as complete",
+            itemOption: "Item ID to check"
+          },
+          uncheck: {
+            description: "Mark a checklist item as incomplete",
+            itemOption: "Item ID to uncheck"
           }
         }
       }
@@ -3298,12 +3332,20 @@ var require_pt_BR = __commonJS((exports, module) => {
       created: '\u2705 Checklist "{{name}}" criado com sucesso!',
       checklistId: "\uD83C\uDD94 ID: {{id}}",
       checklistCard: "\uD83D\uDCCB ID do Card: {{idCard}}",
+      deleted: "\u2705 Checklist deletado com sucesso!",
+      renamed: '\u2705 Checklist renomeado para "{{name}}" com sucesso!',
       itemAdded: '\u2705 Item "{{name}}" adicionado ao checklist com sucesso!',
+      itemDeleted: "\u2705 Item do checklist deletado com sucesso!",
+      itemRenamed: '\u2705 Item renomeado para "{{name}}" com sucesso!',
+      itemChecked: '\u2705 Item "{{name}}" marcado como conclu\xEDdo!',
+      itemUnchecked: '\u2705 Item "{{name}}" marcado como incompleto!',
       itemId: "\uD83C\uDD94 ID: {{id}}",
       itemState: "\uD83D\uDCCC Estado: {{state}}",
+      forceRequired: "\u26A0\uFE0F  Esta opera\xE7\xE3o \xE9 destrutiva. Adicione --force para confirmar.",
       validation: {
         requiredName: "Nome do checklist \xE9 obrigat\xF3rio",
-        requiredItemName: "Nome do item \xE9 obrigat\xF3rio"
+        requiredItemName: "Nome do item \xE9 obrigat\xF3rio",
+        requiredItemId: "ID do item \xE9 obrigat\xF3rio"
       }
     },
     errors: {
@@ -3459,11 +3501,37 @@ var require_pt_BR = __commonJS((exports, module) => {
           description: "Cria um checklist em um card",
           nameOption: "Nome do checklist"
         },
+        delete: {
+          description: "Deleta um checklist",
+          forceOption: "Pular confirma\xE7\xE3o"
+        },
+        rename: {
+          description: "Renomeia um checklist",
+          nameOption: "Novo nome do checklist"
+        },
         item: {
           description: "Gerencia itens de checklist",
           add: {
             description: "Adiciona um item a um checklist",
             nameOption: "Nome do item"
+          },
+          delete: {
+            description: "Deleta um item de um checklist",
+            itemOption: "ID do item a deletar",
+            forceOption: "Pular confirma\xE7\xE3o"
+          },
+          rename: {
+            description: "Renomeia um item de um checklist",
+            itemOption: "ID do item a renomear",
+            nameOption: "Novo nome do item"
+          },
+          check: {
+            description: "Marca um item do checklist como conclu\xEDdo",
+            itemOption: "ID do item a marcar"
+          },
+          uncheck: {
+            description: "Marca um item do checklist como incompleto",
+            itemOption: "ID do item a desmarcar"
           }
         }
       }
@@ -3722,6 +3790,28 @@ class DeleteCardUseCase {
   }
 }
 
+// src/application/use-cases/DeleteChecklistItemUseCase.ts
+class DeleteChecklistItemUseCase {
+  trelloRepository;
+  constructor(trelloRepository) {
+    this.trelloRepository = trelloRepository;
+  }
+  async execute(checklistId, itemId) {
+    await this.trelloRepository.deleteChecklistItem(checklistId, itemId);
+  }
+}
+
+// src/application/use-cases/DeleteChecklistUseCase.ts
+class DeleteChecklistUseCase {
+  trelloRepository;
+  constructor(trelloRepository) {
+    this.trelloRepository = trelloRepository;
+  }
+  async execute(checklistId) {
+    await this.trelloRepository.deleteChecklist(checklistId);
+  }
+}
+
 // src/application/use-cases/GetBoardDetailsUseCase.ts
 class GetBoardDetailsUseCase {
   trelloRepository;
@@ -3811,6 +3901,40 @@ class MoveCardUseCase {
   }
 }
 
+// src/application/use-cases/RenameChecklistItemUseCase.ts
+class RenameChecklistItemUseCase {
+  trelloRepository;
+  constructor(trelloRepository) {
+    this.trelloRepository = trelloRepository;
+  }
+  async execute(cardId, itemId, name) {
+    if (!name.trim()) {
+      throw new Error(t2("checklist.validation.requiredItemName"));
+    }
+    return await this.trelloRepository.renameChecklistItem(cardId, itemId, name);
+  }
+}
+var init_RenameChecklistItemUseCase = __esm(() => {
+  init_i18n();
+});
+
+// src/application/use-cases/RenameChecklistUseCase.ts
+class RenameChecklistUseCase {
+  trelloRepository;
+  constructor(trelloRepository) {
+    this.trelloRepository = trelloRepository;
+  }
+  async execute(checklistId, name) {
+    if (!name.trim()) {
+      throw new Error(t2("checklist.validation.requiredName"));
+    }
+    return await this.trelloRepository.renameChecklist(checklistId, name);
+  }
+}
+var init_RenameChecklistUseCase = __esm(() => {
+  init_i18n();
+});
+
 // src/application/use-cases/UpdateCardUseCase.ts
 class UpdateCardUseCase {
   trelloRepository;
@@ -3828,6 +3952,17 @@ var init_UpdateCardUseCase = __esm(() => {
   init_i18n();
 });
 
+// src/application/use-cases/UpdateChecklistItemStateUseCase.ts
+class UpdateChecklistItemStateUseCase {
+  trelloRepository;
+  constructor(trelloRepository) {
+    this.trelloRepository = trelloRepository;
+  }
+  async execute(cardId, itemId, state) {
+    return await this.trelloRepository.updateChecklistItemState(cardId, itemId, state);
+  }
+}
+
 // src/application/use-cases/index.ts
 var init_use_cases = __esm(() => {
   init_AddChecklistItemUseCase();
@@ -3837,6 +3972,8 @@ var init_use_cases = __esm(() => {
   init_CreateChecklistUseCase();
   init_CreateListUseCase();
   init_GetBoardDetailsUseCase();
+  init_RenameChecklistItemUseCase();
+  init_RenameChecklistUseCase();
   init_UpdateCardUseCase();
 });
 
@@ -26119,11 +26256,21 @@ var init_CardController = __esm(() => {
 class ChecklistController {
   outputFormatter;
   createChecklistUseCase;
+  deleteChecklistUseCase;
+  renameChecklistUseCase;
   addChecklistItemUseCase;
+  deleteChecklistItemUseCase;
+  renameChecklistItemUseCase;
+  updateChecklistItemStateUseCase;
   constructor(trelloRepository, outputFormatter) {
     this.outputFormatter = outputFormatter;
     this.createChecklistUseCase = new CreateChecklistUseCase(trelloRepository);
+    this.deleteChecklistUseCase = new DeleteChecklistUseCase(trelloRepository);
+    this.renameChecklistUseCase = new RenameChecklistUseCase(trelloRepository);
     this.addChecklistItemUseCase = new AddChecklistItemUseCase(trelloRepository);
+    this.deleteChecklistItemUseCase = new DeleteChecklistItemUseCase(trelloRepository);
+    this.renameChecklistItemUseCase = new RenameChecklistItemUseCase(trelloRepository);
+    this.updateChecklistItemStateUseCase = new UpdateChecklistItemStateUseCase(trelloRepository);
   }
   async createChecklist(cardId, name) {
     const checklist = await this.createChecklistUseCase.execute(cardId, name);
@@ -26135,6 +26282,23 @@ class ChecklistController {
       fields: ["id", "name", "idCard", "checkItems"]
     });
   }
+  async deleteChecklist(checklistId, force) {
+    if (!force) {
+      this.outputFormatter.warning(t2("checklist.forceRequired"));
+      return;
+    }
+    await this.deleteChecklistUseCase.execute(checklistId);
+    this.outputFormatter.success(t2("checklist.deleted"));
+  }
+  async renameChecklist(checklistId, name) {
+    const checklist = await this.renameChecklistUseCase.execute(checklistId, name);
+    this.outputFormatter.success(t2("checklist.renamed", { name: checklist.name }));
+    console.log(t2("checklist.checklistId", { id: checklist.id }));
+    this.outputFormatter.output([checklist], {
+      headers: ["ID", "Name", "Card ID"],
+      fields: ["id", "name", "idCard"]
+    });
+  }
   async addChecklistItem(checklistId, name) {
     const item = await this.addChecklistItemUseCase.execute(checklistId, name);
     console.log(t2("checklist.itemAdded", { name: item.name }));
@@ -26145,6 +26309,44 @@ class ChecklistController {
       fields: ["id", "name", "state", "idChecklist"]
     });
   }
+  async deleteChecklistItem(checklistId, itemId, force) {
+    if (!force) {
+      this.outputFormatter.warning(t2("checklist.forceRequired"));
+      return;
+    }
+    await this.deleteChecklistItemUseCase.execute(checklistId, itemId);
+    this.outputFormatter.success(t2("checklist.itemDeleted"));
+  }
+  async renameChecklistItem(cardId, itemId, name) {
+    const item = await this.renameChecklistItemUseCase.execute(cardId, itemId, name);
+    this.outputFormatter.success(t2("checklist.itemRenamed", { name: item.name }));
+    console.log(t2("checklist.itemId", { id: item.id }));
+    console.log(t2("checklist.itemState", { state: item.state }));
+    this.outputFormatter.output([item], {
+      headers: ["ID", "Name", "State", "Checklist ID"],
+      fields: ["id", "name", "state", "idChecklist"]
+    });
+  }
+  async checkItem(cardId, itemId) {
+    const item = await this.updateChecklistItemStateUseCase.execute(cardId, itemId, "complete");
+    this.outputFormatter.success(t2("checklist.itemChecked", { name: item.name }));
+    console.log(t2("checklist.itemId", { id: item.id }));
+    console.log(t2("checklist.itemState", { state: item.state }));
+    this.outputFormatter.output([item], {
+      headers: ["ID", "Name", "State", "Checklist ID"],
+      fields: ["id", "name", "state", "idChecklist"]
+    });
+  }
+  async uncheckItem(cardId, itemId) {
+    const item = await this.updateChecklistItemStateUseCase.execute(cardId, itemId, "incomplete");
+    this.outputFormatter.success(t2("checklist.itemUnchecked", { name: item.name }));
+    console.log(t2("checklist.itemId", { id: item.id }));
+    console.log(t2("checklist.itemState", { state: item.state }));
+    this.outputFormatter.output([item], {
+      headers: ["ID", "Name", "State", "Checklist ID"],
+      fields: ["id", "name", "state", "idChecklist"]
+    });
+  }
 }
 var init_ChecklistController = __esm(() => {
   init_use_cases();
@@ -28626,6 +28828,61 @@ ${errorText}`);
     });
     return ChecklistItemEntity.fromApiResponse(data);
   }
+  async deleteChecklist(checklistId) {
+    await this.request(`/checklists/${checklistId}`, {
+      method: "DELETE"
+    });
+  }
+  async renameChecklist(checklistId, name) {
+    const body = new URLSearchParams({
+      name,
+      key: this.apiKey,
+      token: this.token
+    });
+    const data = await this.request(`/checklists/${checklistId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    return ChecklistEntity.fromApiResponse(data);
+  }
+  async deleteChecklistItem(checklistId, itemId) {
+    await this.request(`/checklists/${checklistId}/checkItems/${itemId}`, {
+      method: "DELETE"
+    });
+  }
+  async renameChecklistItem(cardId, itemId, name) {
+    const body = new URLSearchParams({
+      name,
+      key: this.apiKey,
+      token: this.token
+    });
+    const data = await this.request(`/cards/${cardId}/checklistItem/${itemId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    return ChecklistItemEntity.fromApiResponse(data);
+  }
+  async updateChecklistItemState(cardId, itemId, state) {
+    const body = new URLSearchParams({
+      state,
+      key: this.apiKey,
+      token: this.token
+    });
+    const data = await this.request(`/cards/${cardId}/checklistItem/${itemId}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    return ChecklistItemEntity.fromApiResponse(data);
+  }
 }
 var init_TrelloApiRepository = __esm(() => {
   init_entities();
@@ -31310,6 +31567,21 @@ class CommandController {
         await this.checklistController.createChecklist(cardId, options.name);
       }, "checklists create");
     });
+    checklistsCmd.command("delete <checklistId>").description(t2("commands.checklists.delete.description")).option("--force", t2("commands.checklists.delete.forceOption")).action(async (checklistId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        await this.checklistController.deleteChecklist(checklistId, options.force ?? false);
+      }, "checklists delete");
+    });
+    checklistsCmd.command("rename <checklistId>").description(t2("commands.checklists.rename.description")).requiredOption("-n, --name <name>", t2("commands.checklists.rename.nameOption")).option("-f, --format <format>", t2("commands.formatOption"), "table").action(async (checklistId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        if (options.format) {
+          this.outputFormatter.setFormat(options.format);
+        }
+        await this.checklistController.renameChecklist(checklistId, options.name);
+      }, "checklists rename");
+    });
     const checklistItemCmd = checklistsCmd.command("item").description(t2("commands.checklists.item.description"));
     checklistItemCmd.command("add <checklistId>").description(t2("commands.checklists.item.add.description")).requiredOption("-n, --name <name>", t2("commands.checklists.item.add.nameOption")).option("-f, --format <format>", t2("commands.formatOption"), "table").action(async (checklistId, options) => {
       await ErrorHandler.withErrorHandling(async () => {
@@ -31320,6 +31592,39 @@ class CommandController {
         await this.checklistController.addChecklistItem(checklistId, options.name);
       }, "checklists-item-add");
     });
+    checklistItemCmd.command("delete <checklistId>").description(t2("commands.checklists.item.delete.description")).requiredOption("--item <itemId>", t2("commands.checklists.item.delete.itemOption")).option("--force", t2("commands.checklists.item.delete.forceOption")).action(async (checklistId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        await this.checklistController.deleteChecklistItem(checklistId, options.item, options.force ?? false);
+      }, "checklists-item-delete");
+    });
+    checklistItemCmd.command("rename <cardId>").description(t2("commands.checklists.item.rename.description")).requiredOption("--item <itemId>", t2("commands.checklists.item.rename.itemOption")).requiredOption("-n, --name <name>", t2("commands.checklists.item.rename.nameOption")).option("-f, --format <format>", t2("commands.formatOption"), "table").action(async (cardId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        if (options.format) {
+          this.outputFormatter.setFormat(options.format);
+        }
+        await this.checklistController.renameChecklistItem(cardId, options.item, options.name);
+      }, "checklists-item-rename");
+    });
+    checklistItemCmd.command("check <cardId>").description(t2("commands.checklists.item.check.description")).requiredOption("--item <itemId>", t2("commands.checklists.item.check.itemOption")).option("-f, --format <format>", t2("commands.formatOption"), "table").action(async (cardId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        if (options.format) {
+          this.outputFormatter.setFormat(options.format);
+        }
+        await this.checklistController.checkItem(cardId, options.item);
+      }, "checklists-item-check");
+    });
+    checklistItemCmd.command("uncheck <cardId>").description(t2("commands.checklists.item.uncheck.description")).requiredOption("--item <itemId>", t2("commands.checklists.item.uncheck.itemOption")).option("-f, --format <format>", t2("commands.formatOption"), "table").action(async (cardId, options) => {
+      await ErrorHandler.withErrorHandling(async () => {
+        await this.initializeTrelloControllers();
+        if (options.format) {
+          this.outputFormatter.setFormat(options.format);
+        }
+        await this.checklistController.uncheckItem(cardId, options.item);
+      }, "checklists-item-uncheck");
+    });
   }
   async run() {
     if (!this.program) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trello-cli-unofficial",
   "type": "module",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "private": false,
   "description": "Unofficial Trello CLI using Power-Up authentication, built with Bun for maximum performance",
   "author": "Matheus Caiser <matheus.kaiser@gmail.com> (https://www.mrdeveloper.com.br/)",

package/src/application/use-cases/DeleteChecklistItemUseCase.ts

@@ -0,0 +1,9 @@
+import type { TrelloRepository } from '@domain/repositories';
+
+export class DeleteChecklistItemUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(checklistId: string, itemId: string): Promise<void> {
+    await this.trelloRepository.deleteChecklistItem(checklistId, itemId);
+  }
+}

package/src/application/use-cases/DeleteChecklistUseCase.ts

@@ -0,0 +1,9 @@
+import type { TrelloRepository } from '@domain/repositories';
+
+export class DeleteChecklistUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(checklistId: string): Promise<void> {
+    await this.trelloRepository.deleteChecklist(checklistId);
+  }
+}

package/src/application/use-cases/RenameChecklistItemUseCase.ts

@@ -0,0 +1,15 @@
+import type { ChecklistItemEntity } from '@domain/entities';
+import type { TrelloRepository } from '@domain/repositories';
+import { t } from '@/i18n';
+
+export class RenameChecklistItemUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(cardId: string, itemId: string, name: string): Promise<ChecklistItemEntity> {
+    if (!name.trim()) {
+      throw new Error(t('checklist.validation.requiredItemName'));
+    }
+
+    return await this.trelloRepository.renameChecklistItem(cardId, itemId, name);
+  }
+}

package/src/application/use-cases/RenameChecklistUseCase.ts

@@ -0,0 +1,15 @@
+import type { ChecklistEntity } from '@domain/entities';
+import type { TrelloRepository } from '@domain/repositories';
+import { t } from '@/i18n';
+
+export class RenameChecklistUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(checklistId: string, name: string): Promise<ChecklistEntity> {
+    if (!name.trim()) {
+      throw new Error(t('checklist.validation.requiredName'));
+    }
+
+    return await this.trelloRepository.renameChecklist(checklistId, name);
+  }
+}

package/src/application/use-cases/UpdateChecklistItemStateUseCase.ts

@@ -0,0 +1,14 @@
+import type { ChecklistItemEntity } from '@domain/entities';
+import type { TrelloRepository } from '@domain/repositories';
+
+export class UpdateChecklistItemStateUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(
+    cardId: string,
+    itemId: string,
+    state: 'complete' | 'incomplete',
+  ): Promise<ChecklistItemEntity> {
+    return await this.trelloRepository.updateChecklistItemState(cardId, itemId, state);
+  }
+}

package/src/application/use-cases/index.ts

@@ -5,10 +5,15 @@ export * from './CreateCardUseCase';
 export * from './CreateChecklistUseCase';
 export * from './CreateListUseCase';
 export * from './DeleteCardUseCase';
+export * from './DeleteChecklistItemUseCase';
+export * from './DeleteChecklistUseCase';
 export * from './GetBoardDetailsUseCase';
 export * from './GetBoardsUseCase';
 export * from './GetCardsUseCase';
 export * from './GetCardUseCase';
 export * from './GetListsUseCase';
 export * from './MoveCardUseCase';
+export * from './RenameChecklistItemUseCase';
+export * from './RenameChecklistUseCase';
 export * from './UpdateCardUseCase';
+export * from './UpdateChecklistItemStateUseCase';

package/src/domain/repositories/TrelloRepository.ts

@@ -37,5 +37,10 @@ export interface TrelloRepository {
   deleteCard: (cardId: string) => Promise<void>;
   moveCard: (cardId: string, targetListId: string) => Promise<CardEntity>;
   createChecklist: (cardId: string, name: string) => Promise<ChecklistEntity>;
+  deleteChecklist: (checklistId: string) => Promise<void>;
+  renameChecklist: (checklistId: string, name: string) => Promise<ChecklistEntity>;
   addChecklistItem: (checklistId: string, name: string) => Promise<ChecklistItemEntity>;
+  deleteChecklistItem: (checklistId: string, itemId: string) => Promise<void>;
+  renameChecklistItem: (cardId: string, itemId: string, name: string) => Promise<ChecklistItemEntity>;
+  updateChecklistItemState: (cardId: string, itemId: string, state: 'complete' | 'incomplete') => Promise<ChecklistItemEntity>;
 }

package/src/i18n/locales/en.json

@@ -148,12 +148,20 @@
     "created": "✅ Checklist \"{{name}}\" created successfully!",
     "checklistId": "🆔 ID: {{id}}",
     "checklistCard": "📋 Card ID: {{idCard}}",
+    "deleted": "✅ Checklist deleted successfully!",
+    "renamed": "✅ Checklist renamed to \"{{name}}\" successfully!",
     "itemAdded": "✅ Item \"{{name}}\" added to checklist successfully!",
+    "itemDeleted": "✅ Checklist item deleted successfully!",
+    "itemRenamed": "✅ Item renamed to \"{{name}}\" successfully!",
+    "itemChecked": "✅ Item \"{{name}}\" marked as complete!",
+    "itemUnchecked": "✅ Item \"{{name}}\" marked as incomplete!",
     "itemId": "🆔 ID: {{id}}",
     "itemState": "📌 State: {{state}}",
+    "forceRequired": "⚠️  This operation is destructive. Add --force to confirm.",
     "validation": {
       "requiredName": "Checklist name is required",
-      "requiredItemName": "Item name is required"
+      "requiredItemName": "Item name is required",
+      "requiredItemId": "Item ID is required"
     }
   },
   "errors": {
@@ -309,11 +317,37 @@
         "description": "Create a checklist on a card",
         "nameOption": "Checklist name"
       },
+      "delete": {
+        "description": "Delete a checklist",
+        "forceOption": "Skip confirmation"
+      },
+      "rename": {
+        "description": "Rename a checklist",
+        "nameOption": "New checklist name"
+      },
       "item": {
         "description": "Manage checklist items",
         "add": {
           "description": "Add an item to a checklist",
           "nameOption": "Item name"
+        },
+        "delete": {
+          "description": "Delete an item from a checklist",
+          "itemOption": "Item ID to delete",
+          "forceOption": "Skip confirmation"
+        },
+        "rename": {
+          "description": "Rename an item of a checklist",
+          "itemOption": "Item ID to rename",
+          "nameOption": "New item name"
+        },
+        "check": {
+          "description": "Mark a checklist item as complete",
+          "itemOption": "Item ID to check"
+        },
+        "uncheck": {
+          "description": "Mark a checklist item as incomplete",
+          "itemOption": "Item ID to uncheck"
         }
       }
     }

package/src/i18n/locales/pt-BR.json

@@ -148,12 +148,20 @@
     "created": "✅ Checklist \"{{name}}\" criado com sucesso!",
     "checklistId": "🆔 ID: {{id}}",
     "checklistCard": "📋 ID do Card: {{idCard}}",
+    "deleted": "✅ Checklist deletado com sucesso!",
+    "renamed": "✅ Checklist renomeado para \"{{name}}\" com sucesso!",
     "itemAdded": "✅ Item \"{{name}}\" adicionado ao checklist com sucesso!",
+    "itemDeleted": "✅ Item do checklist deletado com sucesso!",
+    "itemRenamed": "✅ Item renomeado para \"{{name}}\" com sucesso!",
+    "itemChecked": "✅ Item \"{{name}}\" marcado como concluído!",
+    "itemUnchecked": "✅ Item \"{{name}}\" marcado como incompleto!",
     "itemId": "🆔 ID: {{id}}",
     "itemState": "📌 Estado: {{state}}",
+    "forceRequired": "⚠️  Esta operação é destrutiva. Adicione --force para confirmar.",
     "validation": {
       "requiredName": "Nome do checklist é obrigatório",
-      "requiredItemName": "Nome do item é obrigatório"
+      "requiredItemName": "Nome do item é obrigatório",
+      "requiredItemId": "ID do item é obrigatório"
     }
   },
   "errors": {
@@ -309,11 +317,37 @@
         "description": "Cria um checklist em um card",
         "nameOption": "Nome do checklist"
       },
+      "delete": {
+        "description": "Deleta um checklist",
+        "forceOption": "Pular confirmação"
+      },
+      "rename": {
+        "description": "Renomeia um checklist",
+        "nameOption": "Novo nome do checklist"
+      },
       "item": {
         "description": "Gerencia itens de checklist",
         "add": {
           "description": "Adiciona um item a um checklist",
           "nameOption": "Nome do item"
+        },
+        "delete": {
+          "description": "Deleta um item de um checklist",
+          "itemOption": "ID do item a deletar",
+          "forceOption": "Pular confirmação"
+        },
+        "rename": {
+          "description": "Renomeia um item de um checklist",
+          "itemOption": "ID do item a renomear",
+          "nameOption": "Novo nome do item"
+        },
+        "check": {
+          "description": "Marca um item do checklist como concluído",
+          "itemOption": "ID do item a marcar"
+        },
+        "uncheck": {
+          "description": "Marca um item do checklist como incompleto",
+          "itemOption": "ID do item a desmarcar"
         }
       }
     }

package/src/infrastructure/repositories/TrelloApiRepository.ts

@@ -330,4 +330,74 @@ export class TrelloApiRepository implements TrelloRepository {
 
     return ChecklistItemEntity.fromApiResponse(data as TrelloChecklistItemResponse);
   }
+
+  async deleteChecklist(checklistId: string): Promise<void> {
+    await this.request(`/checklists/${checklistId}`, {
+      method: 'DELETE',
+    });
+  }
+
+  async renameChecklist(checklistId: string, name: string): Promise<ChecklistEntity> {
+    const body = new URLSearchParams({
+      name,
+      key: this.apiKey,
+      token: this.token,
+    });
+
+    const data = await this.request(`/checklists/${checklistId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return ChecklistEntity.fromApiResponse(data as TrelloChecklistResponse);
+  }
+
+  async deleteChecklistItem(checklistId: string, itemId: string): Promise<void> {
+    await this.request(`/checklists/${checklistId}/checkItems/${itemId}`, {
+      method: 'DELETE',
+    });
+  }
+
+  async renameChecklistItem(cardId: string, itemId: string, name: string): Promise<ChecklistItemEntity> {
+    const body = new URLSearchParams({
+      name,
+      key: this.apiKey,
+      token: this.token,
+    });
+
+    const data = await this.request(`/cards/${cardId}/checklistItem/${itemId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return ChecklistItemEntity.fromApiResponse(data as TrelloChecklistItemResponse);
+  }
+
+  async updateChecklistItemState(
+    cardId: string,
+    itemId: string,
+    state: 'complete' | 'incomplete',
+  ): Promise<ChecklistItemEntity> {
+    const body = new URLSearchParams({
+      state,
+      key: this.apiKey,
+      token: this.token,
+    });
+
+    const data = await this.request(`/cards/${cardId}/checklistItem/${itemId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return ChecklistItemEntity.fromApiResponse(data as TrelloChecklistItemResponse);
+  }
 }

package/src/presentation/cli/ChecklistController.ts

@@ -4,20 +4,35 @@ import type { OutputFormatter } from '@/shared';
 import {
   AddChecklistItemUseCase,
   CreateChecklistUseCase,
+  DeleteChecklistItemUseCase,
+  DeleteChecklistUseCase,
+  RenameChecklistItemUseCase,
+  RenameChecklistUseCase,
+  UpdateChecklistItemStateUseCase,
 } from '@application/use-cases';
 
 import { t } from '@/i18n';
 
 export class ChecklistController {
   private createChecklistUseCase: CreateChecklistUseCase;
+  private deleteChecklistUseCase: DeleteChecklistUseCase;
+  private renameChecklistUseCase: RenameChecklistUseCase;
   private addChecklistItemUseCase: AddChecklistItemUseCase;
+  private deleteChecklistItemUseCase: DeleteChecklistItemUseCase;
+  private renameChecklistItemUseCase: RenameChecklistItemUseCase;
+  private updateChecklistItemStateUseCase: UpdateChecklistItemStateUseCase;
 
   constructor(
     trelloRepository: TrelloRepository,
     private outputFormatter: OutputFormatter,
   ) {
     this.createChecklistUseCase = new CreateChecklistUseCase(trelloRepository);
+    this.deleteChecklistUseCase = new DeleteChecklistUseCase(trelloRepository);
+    this.renameChecklistUseCase = new RenameChecklistUseCase(trelloRepository);
     this.addChecklistItemUseCase = new AddChecklistItemUseCase(trelloRepository);
+    this.deleteChecklistItemUseCase = new DeleteChecklistItemUseCase(trelloRepository);
+    this.renameChecklistItemUseCase = new RenameChecklistItemUseCase(trelloRepository);
+    this.updateChecklistItemStateUseCase = new UpdateChecklistItemStateUseCase(trelloRepository);
   }
 
   async createChecklist(cardId: string, name: string): Promise<void> {
@@ -33,6 +48,28 @@ export class ChecklistController {
     });
   }
 
+  async deleteChecklist(checklistId: string, force: boolean): Promise<void> {
+    if (!force) {
+      this.outputFormatter.warning(t('checklist.forceRequired'));
+      return;
+    }
+
+    await this.deleteChecklistUseCase.execute(checklistId);
+    this.outputFormatter.success(t('checklist.deleted'));
+  }
+
+  async renameChecklist(checklistId: string, name: string): Promise<void> {
+    const checklist = await this.renameChecklistUseCase.execute(checklistId, name);
+
+    this.outputFormatter.success(t('checklist.renamed', { name: checklist.name }));
+    console.log(t('checklist.checklistId', { id: checklist.id }));
+
+    this.outputFormatter.output([checklist], {
+      headers: ['ID', 'Name', 'Card ID'],
+      fields: ['id', 'name', 'idCard'],
+    });
+  }
+
   async addChecklistItem(checklistId: string, name: string): Promise<void> {
     const item = await this.addChecklistItemUseCase.execute(checklistId, name);
 
@@ -45,4 +82,53 @@ export class ChecklistController {
       fields: ['id', 'name', 'state', 'idChecklist'],
     });
   }
+
+  async deleteChecklistItem(checklistId: string, itemId: string, force: boolean): Promise<void> {
+    if (!force) {
+      this.outputFormatter.warning(t('checklist.forceRequired'));
+      return;
+    }
+
+    await this.deleteChecklistItemUseCase.execute(checklistId, itemId);
+    this.outputFormatter.success(t('checklist.itemDeleted'));
+  }
+
+  async renameChecklistItem(cardId: string, itemId: string, name: string): Promise<void> {
+    const item = await this.renameChecklistItemUseCase.execute(cardId, itemId, name);
+
+    this.outputFormatter.success(t('checklist.itemRenamed', { name: item.name }));
+    console.log(t('checklist.itemId', { id: item.id }));
+    console.log(t('checklist.itemState', { state: item.state }));
+
+    this.outputFormatter.output([item], {
+      headers: ['ID', 'Name', 'State', 'Checklist ID'],
+      fields: ['id', 'name', 'state', 'idChecklist'],
+    });
+  }
+
+  async checkItem(cardId: string, itemId: string): Promise<void> {
+    const item = await this.updateChecklistItemStateUseCase.execute(cardId, itemId, 'complete');
+
+    this.outputFormatter.success(t('checklist.itemChecked', { name: item.name }));
+    console.log(t('checklist.itemId', { id: item.id }));
+    console.log(t('checklist.itemState', { state: item.state }));
+
+    this.outputFormatter.output([item], {
+      headers: ['ID', 'Name', 'State', 'Checklist ID'],
+      fields: ['id', 'name', 'state', 'idChecklist'],
+    });
+  }
+
+  async uncheckItem(cardId: string, itemId: string): Promise<void> {
+    const item = await this.updateChecklistItemStateUseCase.execute(cardId, itemId, 'incomplete');
+
+    this.outputFormatter.success(t('checklist.itemUnchecked', { name: item.name }));
+    console.log(t('checklist.itemId', { id: item.id }));
+    console.log(t('checklist.itemState', { state: item.state }));
+
+    this.outputFormatter.output([item], {
+      headers: ['ID', 'Name', 'State', 'Checklist ID'],
+      fields: ['id', 'name', 'state', 'idChecklist'],
+    });
+  }
 }

package/src/presentation/cli/CommandController.ts

@@ -477,6 +477,32 @@ export class CommandController {
         }, 'checklists create');
       });
 
+    checklistsCmd
+      .command('delete <checklistId>')
+      .description(t('commands.checklists.delete.description'))
+      .option('--force', t('commands.checklists.delete.forceOption'))
+      .action(async (checklistId: string, options: { force?: boolean }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          await this.checklistController.deleteChecklist(checklistId, options.force ?? false);
+        }, 'checklists delete');
+      });
+
+    checklistsCmd
+      .command('rename <checklistId>')
+      .description(t('commands.checklists.rename.description'))
+      .requiredOption('-n, --name <name>', t('commands.checklists.rename.nameOption'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (checklistId: string, options: { name: string; format?: string }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as import('@/shared').OutputFormat);
+          }
+          await this.checklistController.renameChecklist(checklistId, options.name);
+        }, 'checklists rename');
+      });
+
     const checklistItemCmd = checklistsCmd
       .command('item')
       .description(t('commands.checklists.item.description'));
@@ -495,6 +521,64 @@ export class CommandController {
           await this.checklistController.addChecklistItem(checklistId, options.name);
         }, 'checklists-item-add');
       });
+
+    checklistItemCmd
+      .command('delete <checklistId>')
+      .description(t('commands.checklists.item.delete.description'))
+      .requiredOption('--item <itemId>', t('commands.checklists.item.delete.itemOption'))
+      .option('--force', t('commands.checklists.item.delete.forceOption'))
+      .action(async (checklistId: string, options: { item: string; force?: boolean }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          await this.checklistController.deleteChecklistItem(checklistId, options.item, options.force ?? false);
+        }, 'checklists-item-delete');
+      });
+
+    checklistItemCmd
+      .command('rename <cardId>')
+      .description(t('commands.checklists.item.rename.description'))
+      .requiredOption('--item <itemId>', t('commands.checklists.item.rename.itemOption'))
+      .requiredOption('-n, --name <name>', t('commands.checklists.item.rename.nameOption'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (cardId: string, options: { item: string; name: string; format?: string }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as import('@/shared').OutputFormat);
+          }
+          await this.checklistController.renameChecklistItem(cardId, options.item, options.name);
+        }, 'checklists-item-rename');
+      });
+
+    checklistItemCmd
+      .command('check <cardId>')
+      .description(t('commands.checklists.item.check.description'))
+      .requiredOption('--item <itemId>', t('commands.checklists.item.check.itemOption'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (cardId: string, options: { item: string; format?: string }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as import('@/shared').OutputFormat);
+          }
+          await this.checklistController.checkItem(cardId, options.item);
+        }, 'checklists-item-check');
+      });
+
+    checklistItemCmd
+      .command('uncheck <cardId>')
+      .description(t('commands.checklists.item.uncheck.description'))
+      .requiredOption('--item <itemId>', t('commands.checklists.item.uncheck.itemOption'))
+      .option('-f, --format <format>', t('commands.formatOption'), 'table')
+      .action(async (cardId: string, options: { item: string; format?: string }) => {
+        await ErrorHandler.withErrorHandling(async () => {
+          await this.initializeTrelloControllers();
+          if (options.format) {
+            this.outputFormatter.setFormat(options.format as import('@/shared').OutputFormat);
+          }
+          await this.checklistController.uncheckItem(cardId, options.item);
+        }, 'checklists-item-uncheck');
+      });
   }
 
   async run(): Promise<void> {