trello-cli-unofficial 0.1.0

package/install.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+
+# Trello CLI Unofficial - Global Installation Script
+# This script installs the CLI globally on the system
+
+set -e
+
+echo "🚀 Installing Trello CLI Unofficial..."
+
+# Check if bun is installed
+if ! command -v bun &> /dev/null; then
+    echo "❌ Bun is not installed. Install Bun first:"
+    echo "   curl -fsSL https://bun.sh/install | bash"
+    exit 1
+fi
+
+# Check if we're in the correct directory
+if [ ! -f "package.json" ] || [ ! -f "main.ts" ]; then
+    echo "❌ Run this script inside the trello-cli-unofficial project directory"
+    exit 1
+fi
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+bun install
+
+# Create global link
+echo "🔗 Creating global link..."
+bun link
+
+# Verify installation
+if command -v trello-cli-unofficial &> /dev/null; then
+    echo "✅ Installation complete!"
+    echo ""
+    echo "🎯 How to use:"
+    echo "   trello-cli-unofficial          # Interactive mode"
+    echo "   tcu                            # Shortcut (interactive mode)"
+    echo "   tcu boards                     # View boards"
+    echo "   tcu setup                      # Configure token"
+    echo ""
+    echo "📚 For more information, check the README.md"
+else
+    echo "❌ Installation failed. Check permissions and try again."
+    exit 1
+fi

package/main.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+import { config } from 'dotenv';
+import { CommandController } from './src/presentation';
+
+// Load environment variables
+config();
+
+async function main() {
+  try {
+    const commandController = new CommandController();
+    await commandController.run();
+  }
+  catch (error) {
+    console.error('❌ Erro fatal:', (error as Error).message);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "trello-cli-unofficial",
+  "type": "module",
+  "version": "0.1.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/)",
+  "license": "MIT",
+  "homepage": "https://github.com/JaegerCaiser/trello-cli-unofficial#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JaegerCaiser/trello-cli-unofficial.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JaegerCaiser/trello-cli-unofficial/issues"
+  },
+  "keywords": [
+    "trello",
+    "cli",
+    "power-up",
+    "api",
+    "bun",
+    "typescript"
+  ],
+  "module": "main.ts",
+  "bin": {
+    "trello-cli-unofficial": "./main.ts",
+    "tcu": "./main.ts"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "start": "bun run main.ts",
+    "dev": "bun run --watch main.ts",
+    "build": "bun build main.ts --outdir ./dist --target node",
+    "install-global": "./install.sh",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:unit": "bun test tests/unit",
+    "test:integration": "bun test tests/integration",
+    "test:coverage": "bun test --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "tsc --noEmit",
+    "validate": "bun run lint && bun run typecheck && bun run test",
+    "version:patch": "bun version patch && git push --follow-tags",
+    "version:minor": "bun version minor && git push --follow-tags",
+    "version:major": "bun version major && git push --follow-tags",
+    "prepublishOnly": "bun run validate && bun run build"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@types/node": "^24.10.0",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "fs-extra": "^11.3.2",
+    "inquirer": "^12.10.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^6.2.0",
+    "@types/bun": "latest",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "eslint": "^9.39.1",
+    "eslint-plugin-format": "^1.0.2"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/src/application/index.ts

@@ -0,0 +1 @@
+export * from './use-cases';

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

@@ -0,0 +1,47 @@
+import type { ConfigRepository } from '../../domain/repositories';
+import { AuthenticationService } from '../../domain/services';
+
+export class AuthenticateUserUseCase {
+  private authService: AuthenticationService;
+
+  constructor(configRepository: ConfigRepository) {
+    this.authService = new AuthenticationService(configRepository);
+  }
+
+  async execute(
+    token?: string,
+  ): Promise<{ success: boolean; message: string }> {
+    if (token) {
+      if (!this.authService.validateToken(token)) {
+        return {
+          success: false,
+          message:
+            '❌ Token inválido. Deve começar com ATTA e ter pelo menos 10 caracteres.',
+        };
+      }
+
+      await this.authService.saveToken(token);
+      return {
+        success: true,
+        message: '✅ Token configurado com sucesso!',
+      };
+    }
+
+    const isAuthenticated = await this.authService.isAuthenticated();
+    if (isAuthenticated) {
+      return {
+        success: true,
+        message: 'Usuário já autenticado.',
+      };
+    }
+
+    return {
+      success: false,
+      message: '🔐 Você precisa configurar seu token do Trello primeiro.',
+    };
+  }
+
+  async getConfig() {
+    return await this.authService.getConfig();
+  }
+}

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

@@ -0,0 +1,14 @@
+import type { CardEntity, CreateCardData } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class CreateCardUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(cardData: CreateCardData): Promise<CardEntity> {
+    if (!cardData.name.trim()) {
+      throw new Error('Nome do cartão é obrigatório');
+    }
+
+    return await this.trelloRepository.createCard(cardData);
+  }
+}

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

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

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

@@ -0,0 +1,10 @@
+import type { BoardEntity } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class GetBoardsUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(): Promise<BoardEntity[]> {
+    return await this.trelloRepository.getBoards();
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { CardEntity } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class GetCardsUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(listId: string): Promise<CardEntity[]> {
+    return await this.trelloRepository.getCards(listId);
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { ListEntity } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class GetListsUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(boardId: string): Promise<ListEntity[]> {
+    return await this.trelloRepository.getLists(boardId);
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { CardEntity } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class MoveCardUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(cardId: string, targetListId: string): Promise<CardEntity> {
+    return await this.trelloRepository.moveCard(cardId, targetListId);
+  }
+}

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

@@ -0,0 +1,17 @@
+import type { CardEntity, UpdateCardData } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+
+export class UpdateCardUseCase {
+  constructor(private trelloRepository: TrelloRepository) {}
+
+  async execute(
+    cardId: string,
+    updateData: UpdateCardData,
+  ): Promise<CardEntity> {
+    if (updateData.name !== undefined && !updateData.name.trim()) {
+      throw new Error('Nome do cartão não pode estar vazio');
+    }
+
+    return await this.trelloRepository.updateCard(cardId, updateData);
+  }
+}

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

@@ -0,0 +1,8 @@
+export * from './AuthenticateUserUseCase';
+export * from './CreateCardUseCase';
+export * from './DeleteCardUseCase';
+export * from './GetBoardsUseCase';
+export * from './GetCardsUseCase';
+export * from './GetListsUseCase';
+export * from './MoveCardUseCase';
+export * from './UpdateCardUseCase';

package/src/domain/entities/Board.ts

@@ -0,0 +1,17 @@
+export interface Board {
+  id: string;
+  name: string;
+  url: string;
+}
+
+export class BoardEntity implements Board {
+  constructor(
+    public readonly id: string,
+    public readonly name: string,
+    public readonly url: string,
+  ) {}
+
+  static fromApiResponse(data: any): BoardEntity {
+    return new BoardEntity(data.id, data.name, data.url);
+  }
+}

package/src/domain/entities/Card.ts

@@ -0,0 +1,53 @@
+export interface Card {
+  id: string;
+  name: string;
+  desc?: string;
+  idList: string;
+  url?: string;
+}
+
+export interface CreateCardData {
+  name: string;
+  desc?: string;
+  listId: string;
+}
+
+export interface UpdateCardData {
+  name?: string;
+  desc?: string;
+  idList?: string;
+}
+
+export class CardEntity implements Card {
+  constructor(
+    public readonly id: string,
+    public readonly name: string,
+    public readonly idList: string,
+    public readonly desc?: string,
+    public readonly url?: string,
+  ) {}
+
+  static fromApiResponse(data: any): CardEntity {
+    return new CardEntity(data.id, data.name, data.idList, data.desc, data.url);
+  }
+
+  static create(
+    data: CreateCardData,
+  ): Pick<CardEntity, 'name' | 'desc' | 'idList'> {
+    return {
+      name: data.name,
+      desc: data.desc,
+      idList: data.listId,
+    };
+  }
+
+  update(data: UpdateCardData): CardEntity {
+    return new CardEntity(
+      this.id,
+      data.name ?? this.name,
+      data.idList ?? this.idList,
+      data.desc ?? this.desc,
+      this.url,
+    );
+  }
+}

package/src/domain/entities/Config.ts

@@ -0,0 +1,20 @@
+export interface Config {
+  apiKey: string;
+  token?: string;
+}
+
+export class ConfigEntity implements Config {
+  constructor(public readonly apiKey: string, public readonly token?: string) {}
+
+  static createDefault(): ConfigEntity {
+    return new ConfigEntity('630a01228b85df706aa520f3611e6490');
+  }
+
+  withToken(token: string): ConfigEntity {
+    return new ConfigEntity(this.apiKey, token);
+  }
+
+  hasValidToken(): boolean {
+    return !!(this.token && this.token.startsWith('ATTA'));
+  }
+}

package/src/domain/entities/List.ts

@@ -0,0 +1,12 @@
+export interface List {
+  id: string;
+  name: string;
+}
+
+export class ListEntity implements List {
+  constructor(public readonly id: string, public readonly name: string) {}
+
+  static fromApiResponse(data: any): ListEntity {
+    return new ListEntity(data.id, data.name);
+  }
+}

package/src/domain/entities/index.ts

@@ -0,0 +1,4 @@
+export * from './Board';
+export * from './Card';
+export * from './Config';
+export * from './List';

package/src/domain/index.ts

@@ -0,0 +1,3 @@
+export * from './entities';
+export * from './repositories';
+export * from './services';

package/src/domain/repositories/ConfigRepository.ts

@@ -0,0 +1,6 @@
+import type { ConfigEntity } from '../entities';
+
+export interface ConfigRepository {
+  load: () => Promise<ConfigEntity>;
+  save: (config: ConfigEntity) => Promise<void>;
+}

package/src/domain/repositories/TrelloRepository.ts

@@ -0,0 +1,11 @@
+import type { BoardEntity, CardEntity, CreateCardData, ListEntity, UpdateCardData } from '../entities';
+
+export interface TrelloRepository {
+  getBoards: () => Promise<BoardEntity[]>;
+  getLists: (boardId: string) => Promise<ListEntity[]>;
+  getCards: (listId: string) => Promise<CardEntity[]>;
+  createCard: (data: CreateCardData) => Promise<CardEntity>;
+  updateCard: (cardId: string, data: UpdateCardData) => Promise<CardEntity>;
+  deleteCard: (cardId: string) => Promise<void>;
+  moveCard: (cardId: string, targetListId: string) => Promise<CardEntity>;
+}

package/src/domain/repositories/index.ts

@@ -0,0 +1,2 @@
+export * from './ConfigRepository';
+export * from './TrelloRepository';

package/src/domain/services/AuthenticationService.ts

@@ -0,0 +1,26 @@
+import type { ConfigEntity } from '../entities';
+import type { ConfigRepository } from '../repositories';
+
+export class AuthenticationService {
+  constructor(private configRepository: ConfigRepository) {}
+
+  async getConfig(): Promise<ConfigEntity> {
+    return await this.configRepository.load();
+  }
+
+  async saveToken(token: string): Promise<ConfigEntity> {
+    const config = await this.configRepository.load();
+    const updatedConfig = config.withToken(token);
+    await this.configRepository.save(updatedConfig);
+    return updatedConfig;
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    const config = await this.configRepository.load();
+    return config.hasValidToken();
+  }
+
+  validateToken(token: string): boolean {
+    return token.startsWith('ATTA') && token.length > 10;
+  }
+}

package/src/domain/services/index.ts

@@ -0,0 +1 @@
+export * from './AuthenticationService';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './application';
+export * from './domain';
+export * from './infrastructure';
+export * from './presentation';
+export * from './shared';

package/src/infrastructure/index.ts

@@ -0,0 +1 @@
+export * from './repositories';

package/src/infrastructure/repositories/FileConfigRepository.ts

@@ -0,0 +1,51 @@
+import type { ConfigRepository } from '../../domain/repositories';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { ConfigEntity } from '../../domain/entities';
+
+export class FileConfigRepository implements ConfigRepository {
+  private readonly configDir: string;
+  private readonly configFile: string;
+
+  constructor() {
+    this.configDir = path.join(
+      process.env.HOME || '~',
+      '.trello-cli-unofficial',
+    );
+    this.configFile = path.join(this.configDir, 'config.json');
+  }
+
+  async load(): Promise<ConfigEntity> {
+    try {
+      if (await fs.pathExists(this.configFile)) {
+        const data = await fs.readJson(this.configFile);
+        return new ConfigEntity(
+          data.apiKey || '630a01228b85df706aa520f3611e6490',
+          data.token || process.env.TRELLO_TOKEN,
+        );
+      }
+    }
+    catch (error) {
+      console.error('Error loading config:', (error as Error).message);
+    }
+
+    return ConfigEntity.createDefault();
+  }
+
+  async save(config: ConfigEntity): Promise<void> {
+    try {
+      await fs.ensureDir(this.configDir);
+      await fs.writeJson(
+        this.configFile,
+        {
+          apiKey: config.apiKey,
+          token: config.token,
+        },
+        { spaces: 2 },
+      );
+    }
+    catch (error) {
+      console.error('Error saving config:', (error as Error).message);
+    }
+  }
+}

package/src/infrastructure/repositories/TrelloApiRepository.ts

@@ -0,0 +1,93 @@
+import type { CreateCardData, UpdateCardData } from '../../domain/entities';
+import type { TrelloRepository } from '../../domain/repositories';
+import { BoardEntity, CardEntity, ListEntity } from '../../domain/entities';
+
+export class TrelloApiRepository implements TrelloRepository {
+  private readonly baseUrl = 'https://api.trello.com/1';
+
+  constructor(
+    private readonly apiKey: string,
+    private readonly token: string,
+  ) {}
+
+  private async request(endpoint: string, options?: RequestInit): Promise<any> {
+    const url = `${this.baseUrl}${endpoint}?key=${this.apiKey}&token=${this.token}`;
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Trello API error: ${response.status} ${response.statusText}\n${errorText}`,
+      );
+    }
+
+    return response.json();
+  }
+
+  async getBoards(): Promise<BoardEntity[]> {
+    const data = await this.request('/members/me/boards');
+    return data.map((board: any) => BoardEntity.fromApiResponse(board));
+  }
+
+  async getLists(boardId: string): Promise<ListEntity[]> {
+    const data = await this.request(`/boards/${boardId}/lists`);
+    return data.map((list: any) => ListEntity.fromApiResponse(list));
+  }
+
+  async getCards(listId: string): Promise<CardEntity[]> {
+    const data = await this.request(`/lists/${listId}/cards`);
+    return data.map((card: any) => CardEntity.fromApiResponse(card));
+  }
+
+  async createCard(cardData: CreateCardData): Promise<CardEntity> {
+    const body = new URLSearchParams({
+      idList: cardData.listId,
+      name: cardData.name,
+      desc: cardData.desc || '',
+      key: this.apiKey,
+      token: this.token,
+    });
+
+    const data = await this.request('/cards', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return CardEntity.fromApiResponse(data);
+  }
+
+  async updateCard(
+    cardId: string,
+    updates: UpdateCardData,
+  ): Promise<CardEntity> {
+    const body = new URLSearchParams({
+      key: this.apiKey,
+      token: this.token,
+      ...updates,
+    });
+
+    const data = await this.request(`/cards/${cardId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return CardEntity.fromApiResponse(data);
+  }
+
+  async deleteCard(cardId: string): Promise<void> {
+    await this.request(`/cards/${cardId}`, {
+      method: 'DELETE',
+    });
+  }
+
+  async moveCard(cardId: string, targetListId: string): Promise<CardEntity> {
+    return this.updateCard(cardId, { idList: targetListId });
+  }
+}

package/src/infrastructure/repositories/index.ts

@@ -0,0 +1,2 @@
+export * from './FileConfigRepository';
+export * from './TrelloApiRepository';