Como Desenvolver Ferramentas CLI com Claude Code

Acelerando o Desenvolvimento de Ferramentas CLI com Claude Code

Quando você quer criar sua própria ferramenta CLI, o Claude Code é o parceiro ideal. Desde parsing de argumentos, design de subcomandos até entrada/saída interativa, basta descrever “quero criar uma CLI assim” para implementar.

Estrutura Inicial do Projeto

> Crie um projeto de ferramenta CLI em TypeScript.
> Parse de argumentos com commander, configure eslint e prettier.
> Execute com npx ts-node src/index.ts.

Parsing de Argumentos e Subcomandos

Estrutura básica de CLI usando Commander.

#!/usr/bin/env node
import { Command } from "commander";
import { version } from "../package.json";

const program = new Command();

program
  .name("mytool")
  .description("Ferramenta CLI de gerenciamento de projetos")
  .version(version);

program
  .command("init")
  .description("Inicializar o projeto")
  .option("-t, --template <name>", "Nome do template", "default")
  .option("-d, --dir <path>", "Diretório de destino", ".")
  .action(async (options) => {
    console.log(`Inicializando com template "${options.template}"...`);
    await initProject(options.template, options.dir);
    console.log("Concluído!");
  });

program
  .command("generate <type> <name>")
  .alias("g")
  .description("Gerar arquivo (component, hook, page)")
  .option("--dry-run", "Pré-visualizar sem criar arquivos")
  .action(async (type, name, options) => {
    if (options.dryRun) {
      console.log(`[dry-run] Gerando ${type} "${name}"`);
      return;
    }
    await generateFile(type, name);
  });

program
  .command("check")
  .description("Verificar o estado do projeto")
  .action(async () => {
    await runHealthCheck();
  });

program.parse();

Entrada Interativa

Implementação de entrada interativa usando a biblioteca Inquirer.

import inquirer from "inquirer";
import chalk from "chalk";

interface ProjectConfig {
  name: string;
  framework: string;
  features: string[];
  packageManager: string;
}

async function interactiveInit(): Promise<ProjectConfig> {
  const answers = await inquirer.prompt([
    {
      type: "input",
      name: "name",
      message: "Nome do projeto:",
      validate: (input: string) =>
        /^[a-z0-9-]+$/.test(input) || "Apenas letras minúsculas, números e hifens são permitidos",
    },
    {
      type: "list",
      name: "framework",
      message: "Framework:",
      choices: ["React", "Next.js", "Astro", "Vue"],
    },
    {
      type: "checkbox",
      name: "features",
      message: "Funcionalidades adicionais:",
      choices: [
        { name: "TypeScript", checked: true },
        { name: "ESLint", checked: true },
        { name: "Prettier", checked: true },
        { name: "Testing (Vitest)" },
        { name: "CI/CD (GitHub Actions)" },
      ],
    },
    {
      type: "list",
      name: "packageManager",
      message: "Gerenciador de pacotes:",
      choices: ["npm", "pnpm", "yarn"],
    },
  ]);

  console.log(chalk.green("\nConfiguração:"));
  console.log(chalk.cyan(`  Nome do projeto: ${answers.name}`));
  console.log(chalk.cyan(`  Framework: ${answers.framework}`));
  console.log(chalk.cyan(`  Funcionalidades: ${answers.features.join(", ")}`));

  return answers;
}

Barra de Progresso e Spinner

Exibindo visualmente o progresso do processamento.

import ora from "ora";
import cliProgress from "cli-progress";

async function processFiles(files: string[]) {
  const bar = new cliProgress.SingleBar({
    format: "Processando |{bar}| {percentage}% | {value}/{total} arquivos",
    barCompleteChar: "█",
    barIncompleteChar: "░",
  });

  bar.start(files.length, 0);

  for (const file of files) {
    await processFile(file);
    bar.increment();
  }

  bar.stop();
  console.log(chalk.green("Processamento de todos os arquivos concluído!"));
}

async function installDependencies(packages: string[]) {
  const spinner = ora("Instalando pacotes de dependência...").start();

  try {
    await execAsync(`npm install ${packages.join(" ")}`);
    spinner.succeed("Instalação de pacotes de dependência concluída");
  } catch (error) {
    spinner.fail("Falha na instalação");
    throw error;
  }
}

Implementação de Testes

Você também pode pedir ao Claude Code para criar testes para a ferramenta CLI.

import { describe, it, expect } from "vitest";
import { execSync } from "child_process";

describe("mytool CLI", () => {
  it("pode exibir a versão", () => {
    const output = execSync("npx ts-node src/index.ts --version").toString();
    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
  });

  it("pode exibir a ajuda", () => {
    const output = execSync("npx ts-node src/index.ts --help").toString();
    expect(output).toContain("Ferramenta CLI de gerenciamento de projetos");
    expect(output).toContain("init");
    expect(output).toContain("generate");
  });

  it("retorna erro para comando inexistente", () => {
    expect(() => {
      execSync("npx ts-node src/index.ts unknown 2>&1");
    }).toThrow();
  });
});

Para saber como publicar como pacote npm, consulte Publicação de Pacote npm. Para o uso básico do Claude Code, consulte o Guia de Introdução, e para dicas de produtividade, consulte 10 Dicas para Triplicar sua Produtividade.

Resumo

Com o Claude Code, você pode desenvolver ferramentas CLI em pouco tempo, incluindo parsing de argumentos, entrada interativa, exibição de progresso e testes. Basta descrever em linguagem natural “quero este comando” para ter uma ferramenta funcional pronta.

Para mais detalhes, consulte a documentação oficial do Claude Code.