CLI-Tools mit Claude Code entwickeln

CLI-Tool-Entwicklung mit Claude Code beschleunigen

Wenn Sie Ihr eigenes CLI-Tool erstellen möchten, ist Claude Code der ideale Partner. Von der Argumentverarbeitung über Subcommand-Design bis hin zu interaktiver Ein-/Ausgabe - beschreiben Sie einfach, welches CLI Sie möchten, und es wird implementiert.

Initiale Projektstruktur

> Erstelle ein CLI-Tool-Projekt in TypeScript.
> Argumente mit Commander parsen, ESLint und Prettier einrichten.
> Ausführbar via npx ts-node src/index.ts.

Argumentverarbeitung und Subcommands

Grundstruktur eines CLI mit Commander.

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

const program = new Command();

program
  .name("mytool")
  .description("Projektmanagement-CLI-Tool")
  .version(version);

program
  .command("init")
  .description("Projekt initialisieren")
  .option("-t, --template <name>", "Vorlagenname", "default")
  .option("-d, --dir <path>", "Zielverzeichnis", ".")
  .action(async (options) => {
    console.log(`Initialisiere mit Vorlage "${options.template}"...`);
    await initProject(options.template, options.dir);
    console.log("Abgeschlossen!");
  });

program
  .command("generate <type> <name>")
  .alias("g")
  .description("Datei generieren (component, hook, page)")
  .option("--dry-run", "Vorschau ohne Dateierstellung")
  .action(async (type, name, options) => {
    if (options.dryRun) {
      console.log(`[dry-run] Generiere ${type} "${name}"`);
      return;
    }
    await generateFile(type, name);
  });

program
  .command("check")
  .description("Projektstatus überprüfen")
  .action(async () => {
    await runHealthCheck();
  });

program.parse();

Interaktive Eingabe

Implementierung interaktiver Eingaben mit der Inquirer-Bibliothek.

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: "Projektname:",
      validate: (input: string) =>
        /^[a-z0-9-]+$/.test(input) || "Nur Kleinbuchstaben, Zahlen und Bindestriche erlaubt",
    },
    {
      type: "list",
      name: "framework",
      message: "Framework:",
      choices: ["React", "Next.js", "Astro", "Vue"],
    },
    {
      type: "checkbox",
      name: "features",
      message: "Zusätzliche Funktionen:",
      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: "Paketmanager:",
      choices: ["npm", "pnpm", "yarn"],
    },
  ]);

  console.log(chalk.green("\nKonfiguration:"));
  console.log(chalk.cyan(`  Projektname: ${answers.name}`));
  console.log(chalk.cyan(`  Framework: ${answers.framework}`));
  console.log(chalk.cyan(`  Funktionen: ${answers.features.join(", ")}`));

  return answers;
}

Fortschrittsbalken und Spinner

Visuelle Darstellung des Verarbeitungsfortschritts.

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

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

  bar.start(files.length, 0);

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

  bar.stop();
  console.log(chalk.green("Alle Dateien wurden erfolgreich verarbeitet!"));
}

async function installDependencies(packages: string[]) {
  const spinner = ora("Installiere Abhängigkeiten...").start();

  try {
    await execAsync(`npm install ${packages.join(" ")}`);
    spinner.succeed("Abhängigkeiten erfolgreich installiert");
  } catch (error) {
    spinner.fail("Installation fehlgeschlagen");
    throw error;
  }
}

Test-Implementierung

Auch Tests für CLI-Tools können Sie an Claude Code delegieren.

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

describe("mytool CLI", () => {
  it("kann die Version anzeigen", () => {
    const output = execSync("npx ts-node src/index.ts --version").toString();
    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
  });

  it("kann die Hilfe anzeigen", () => {
    const output = execSync("npx ts-node src/index.ts --help").toString();
    expect(output).toContain("Projektmanagement-CLI-Tool");
    expect(output).toContain("init");
    expect(output).toContain("generate");
  });

  it("gibt einen Fehler bei unbekanntem Befehl", () => {
    expect(() => {
      execSync("npx ts-node src/index.ts unknown 2>&1");
    }).toThrow();
  });
});

Zur Veröffentlichung als npm-Paket siehe npm-Paket veröffentlichen. Die grundlegende Verwendung von Claude Code finden Sie im Einsteiger-Leitfaden, Tipps zur Produktivitätssteigerung unter 10 Tipps für 3-fache Produktivität.

Zusammenfassung

Mit Claude Code können Sie in kurzer Zeit CLI-Tools entwickeln, die Argumentverarbeitung, interaktive Eingabe, Fortschrittsanzeige und Tests umfassen. Beschreiben Sie einfach in natürlicher Sprache, welchen Befehl Sie benötigen, und Sie erhalten ein sofort funktionsfähiges Tool.

Weitere Details finden Sie in der offiziellen Claude Code-Dokumentation.