Add AI to Your CLI Tool with 20 Lines of Code

AI-powered CLI tools are the next evolution of developer tooling. Instead of rigid commands with fixed logic, your tool can understand natural language queries, generate code, summarize data, and make intelligent suggestions. And with modern AI APIs, adding this takes surprisingly little code.

This article shows how to integrate OpenAI, Anthropic, or local models into any Node.js CLI tool — from basic completions to streaming output and tool use.

The Simplest Integration: 20 Lines

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

export async function askAI(prompt: string, context?: string): Promise<string> {
  const messages = [];

  if (context) {
    messages.push({ role: 'user', content: context });
    messages.push({ role: 'assistant', content: 'I understand the context. What would you like to know?' });
  }

  messages.push({ role: 'user', content: prompt });

  const response = await client.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages,
  });

  return response.content[0].text;
}

That's it. Your CLI can now answer questions, analyze data, and generate content.

Use Case 1: Smart Error Explanations

When your tool encounters an error, explain it in plain English:

program
  .command('check <file>')
  .option('--explain', 'Use AI to explain errors')
  .action(async (file, options) => {
    const errors = await runCheck(file);

    for (const error of errors) {
      console.log(chalk.red(`  ✗ ${error.message}`));

      if (options.explain) {
        const explanation = await askAI(
          `Explain this error in plain English and suggest a fix: ${error.message}`,
          `File: ${file}, Line: ${error.line}, Code: ${error.code}`
        );
        console.log(chalk.gray(`  ${explanation}\n`));
      }
    }
  });

Use Case 2: Natural Language Queries

Let users ask questions about their data:

program
  .command('ask <question>')
  .description('Ask a natural language question about your project')
  .action(async (question) => {
    // Gather context
    const pkg = JSON.parse(await readFile('package.json', 'utf-8'));
    const deps = Object.keys(pkg.dependencies || {});

    const context = `
      Project: ${pkg.name} v${pkg.version}
      Dependencies: ${deps.join(', ')}
      Scripts: ${Object.keys(pkg.scripts || {}).join(', ')}
    `;

    const answer = await askAI(question, context);
    console.log(answer);
  });

mytool ask "what testing framework does this project use?"
# → Based on the dependencies, this project uses Vitest for testing...

mytool ask "how do I run the development server?"
# → Run `npm run dev` which starts the development server...

Use Case 3: Streaming Output

For long responses, stream tokens as they arrive:

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function streamAI(prompt: string): Promise<void> {
  const stream = client.messages.stream({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    messages: [{ role: 'user', content: prompt }],
  });

  for await (const event of stream) {
    if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
      process.stdout.write(event.delta.text);
    }
  }
  console.log(); // Final newline
}

Use Case 4: Code Generation

program
  .command('generate <description>')
  .description('Generate code from a natural language description')
  .option('-l, --language <lang>', 'Target language', 'typescript')
  .action(async (description, options) => {
    const prompt = `Generate ${options.language} code for: ${description}

Rules:
- Only output the code, no explanations
- Include necessary imports
- Add brief inline comments
- Make it production-ready`;

    console.log(chalk.gray('  Generating...\n'));
    await streamAI(prompt);
  });

mytool generate "a function that retries a fetch request with exponential backoff"

Use Case 5: AI-Powered Data Analysis

program
  .command('analyze <file>')
  .description('AI-powered analysis of a data file')
  .action(async (file) => {
    const content = await readFile(file, 'utf-8');

    // Truncate if too large
    const sample = content.length > 10000
      ? content.slice(0, 10000) + '\n... (truncated)'
      : content;

    const analysis = await askAI(
      `Analyze this data and provide key insights, anomalies, and recommendations:\n\n${sample}`,
    );

    console.log(chalk.bold('\n  AI Analysis:\n'));
    console.log(`  ${analysis.replace(/\n/g, '\n  ')}\n`);
  });

Cost Management

AI API calls cost money. Be smart about it:

// Cache responses for identical queries
const cache = new Map<string, { response: string; timestamp: number }>();

async function cachedAskAI(prompt: string, ttlMs = 3600000): Promise<string> {
  const key = createHash('md5').update(prompt).digest('hex');
  const cached = cache.get(key);

  if (cached && Date.now() - cached.timestamp < ttlMs) {
    return cached.response;
  }

  const response = await askAI(prompt);
  cache.set(key, { response, timestamp: Date.now() });
  return response;
}

Also:

• Use smaller models for simple tasks (haiku for classification, sonnet for generation)
• Truncate input data to what's needed
• Make AI features opt-in (--explain, --ai, --smart)
• Show cost estimates for expensive operations

API Key Management

function getApiKey(): string {
  // 1. Environment variable
  const key = process.env.ANTHROPIC_API_KEY;
  if (key) return key;

  // 2. Stored credential
  const stored = loadCredential('anthropic');
  if (stored) return stored;

  // 3. Prompt
  console.error(chalk.yellow('  AI features require an API key'));
  console.error(chalk.gray('  Set ANTHROPIC_API_KEY or run: mytool config set api-key <key>'));
  process.exit(2);
}

When to Add AI

Add AI when:

• Error explanation — AI can contextualize errors better than static messages
• Data analysis — patterns in logs, metrics, or configs
• Code generation — boilerplate, configs, migrations
• Natural language queries — "what's wrong with my setup?"

Don't add AI when:

• Deterministic logic — sorting, filtering, formatting
• Performance-critical paths — API calls add latency
• Simple transformations — regex, string ops, math

Conclusion

AI in CLI tools isn't about replacing logic — it's about augmenting it. Keep your core tool deterministic and fast. Add AI as opt-in features that make the tool smarter when users want intelligence. Twenty lines of code, and your CLI goes from good to remarkable.

---

Wilson Xu builds AI-powered developer tools. Find his 16+ npm packages at npmjs.com/~chengyixu.