Создаем утилиты CLI с помощью Node.js

#!/usr/bin/env node
 
const program = require('./lib/cli');
program.run(process.argv.slice(2));

const { Command } = require('commander');
const { version } = require('../package.json');
 
const program = new Command();
 
program
  .version(version)
  .description('An awesome CLI tool')
  .option('-d, --debug', 'enable debugging')
  .option('-c, --config <path>', 'specify config file');
 
// Команда с аргументами
program
  .command('transform <file>')
  .description('Transform a file')
  .option('-o, --output <file>', 'output file')
  .action((file, options) => {
    console.log(`Transforming ${file}...`);
    if (options.output) {
      console.log(`Output will be saved to ${options.output}`);
    }
  });
 
// Обработка неизвестных команд
program.on('command:*', () => {
  console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
  process.exit(1);
});
 
module.exports = program;

// lib/commands/transform.js
module.exports = {
  command: 'transform <file>',
  description: 'Transform a file',
  options: [
    ['-o, --output <file>', 'output file']
  ],
  action: (file, options) => {
    console.log(`Transforming ${file}...`);
    if (options.output) {
      console.log(`Output will be saved to ${options.output}`);
    }
  }
};
 
// lib/cli.js (переработанный вариант)
const { Command } = require('commander');
const { version } = require('../package.json');
const transformCommand = require('./commands/transform');
 
const program = new Command();
 
program
  .version(version)
  .description('An awesome CLI tool')
  .option('-d, --debug', 'enable debugging')
  .option('-c, --config <path>', 'specify config file');
 
// Регистрация команды
program
  .command(transformCommand.command)
  .description(transformCommand.description)
  .action(transformCommand.action);
 
transformCommand.options.forEach(option => {
  program.option(option[0], option[1]);
});
 
module.exports = program;

// lib/config.js
const Conf = require('conf');
 
const config = new Conf({
  projectName: 'my-cli-tool',
  defaults: {
    theme: 'default',
    logLevel: 'info'
  }
});
 
module.exports = config;

// lib/config-loader.js
const { cosmiconfig } = require('cosmiconfig');
 
const explorer = cosmiconfig('my-tool');
 
async function loadConfig() {
  try {
    const result = await explorer.search();
    return result ? result.config : {};
  } catch (error) {
    console.error('Error loading config:', error);
    return {};
  }
}
 
module.exports = { loadConfig };

// lib/config-manager.js
const os = require('os');
const path = require('path');
const fs = require('fs');
const { loadConfig } = require('./config-loader');
const defaultConfig = require('./default-config');
 
async function getConfig(cliOptions) {
  // Загрузка глобальной конфигурации
  const globalConfigPath = path.join(os.homedir(), '.my-tool-config.json');
  let globalConfig = {};
  try {
    if (fs.existsSync(globalConfigPath)) {
      globalConfig = JSON.parse(fs.readFileSync(globalConfigPath, 'utf8'));
    }
  } catch (error) {
    console.warn('Ошибка чтения глобальной конфигурации:', error.message);
  }
  
  // Загрузка локальной конфигурации
  const localConfig = await loadConfig();
  
  // Получение переменных окружения с префиксом MY_TOOL_
  const envConfig = Object.keys(process.env)
    .filter(key => key.startsWith('MY_TOOL_'))
    .reduce((config, key) => {
      // Преобразование MY_TOOL_LOG_LEVEL в logLevel
      const configKey = key.replace('MY_TOOL_', '')
        .toLowerCase()
        .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
      config[configKey] = process.env[key];
      return config;
    }, {});
  
  // Объединение конфигураций с соблюдением приоритетов
  return {
    ...defaultConfig,
    ...globalConfig,
    ...localConfig,
    ...envConfig,
    ...cliOptions
  };
}
 
module.exports = { getConfig };

// lib/error-handler.js
function handleError(error, debug = false) {
  if (debug) {
    console.error('Ошибка:', error);
  } else {
    console.error(`Ошибка: ${error.message}`);
  }
  process.exit(1);
}
 
module.exports = { handleError };

// lib/utils/logger.js
const debug = require('debug')('my-tool');
 
module.exports = {
  debug,
  info: console.log,
  warn: console.warn,
  error: console.error
};

// Определение параметров со значениями по умолчанию
program
  .option('-t, --timeout <ms>', 'задержка в миллисекундах', 1000)
  .option('-r, --retries <n>', 'количество повторных попыток', parseInt, 3);
 
// Взаимоисключающие опции
program
  .addOption(new Option('-s, --small', 'маленький размер'))
  .addOption(new Option('-b, --big', 'большой размер').conflicts('small'));
 
// Обязательные параметры
program
  .requiredOption('-n, --name <name>', 'имя проекта (обязательно)');
 
// Переменное количество аргументов
program
  .command('copy <source...> <dest>')
  .action((source, dest) => {
    console.log(`Копирование ${source.join(', ')} в ${dest}`);
  });

const { InvalidArgumentError } = require('commander');
 
// Функция валидации для commander
function parseInteger(value) {
  const parsedValue = parseInt(value, 10);
  if (isNaN(parsedValue)) {
    throw new InvalidArgumentError('Должно быть числом.');
  }
  return parsedValue;
}
 
// Применение валидатора
program
  .option('-p, --port <number>', 'порт сервера', parseInteger)
  .option('-i, --iterations <n>', 'количество итераций', parseInteger);
 
// Более сложная валидация
function validateEmail(value) {
  if (!/\S+@\S+\.\S+/.test(value)) {
    throw new InvalidArgumentError('Неверный формат email.');
  }
  return value;
}
 
program
  .option('-e, --email <email>', 'email для уведомлений', validateEmail);

const inquirer = require('inquirer');
 
async function promptUser() {
  const answers = await inquirer.prompt([
    {
      type: 'input',
      name: 'name',
      message: 'Введите имя проекта:',
      validate: input => input.trim() !== '' ? true : 'Имя не может быть пустым'
    },
    {
      type: 'list',
      name: 'type',
      message: 'Выберите тип проекта:',
      choices: ['web', 'mobile', 'desktop']
    },
    {
      type: 'checkbox',
      name: 'features',
      message: 'Выберите фичи:',
      choices: [
        { name: 'TypeScript', checked: true },
        'ESLint',
        'Jest'
      ]
    },
    {
      type: 'confirm',
      name: 'confirm',
      message: 'Продолжить?',
      default: true
    }
  ]);
  
  console.log('Ответы:', answers);
  return answers;
}

const ora = require('ora');
const ProgressBar = require('progress');
 
// Использование спиннера
async function runWithSpinner() {
  const spinner = ora('Обработка данных...').start();
  
  try {
    await someAsyncOperation();
    spinner.succeed('Данные успешно обработаны!');
  } catch (error) {
    spinner.fail('Ошибка обработки данных.');
    throw error;
  }
}
 
// Использование прогресс-бара
function runWithProgress(total) {
  const bar = new ProgressBar('Загрузка [:bar] :percent :etas', {
    complete: '=',
    incomplete: ' ',
    width: 30,
    total
  });
  
  return {
    increment: () => bar.tick(),
    finish: () => {
      bar.tick(total - bar.curr);
      console.log('Загрузка завершена!');
    }
  };
}
 
// Применение
async function processFiles(files) {
  const progress = runWithProgress(files.length);
  
  for (const file of files) {
    await processFile(file);
    progress.increment();
  }
  
  progress.finish();
}

const chalk = require('chalk');
 
// Базовое использование
console.log(chalk.blue('Информация'));
console.log(chalk.green('Успех!'));
console.log(chalk.yellow('Предупреждение'));
console.log(chalk.red('Ошибка!'));
 
// Комбинирование стилей
console.log(chalk.bold.underline.green('Важное сообщение!'));
 
// Создание тем
const theme = {
  info: chalk.blue,
  success: chalk.bold.green,
  warning: chalk.keyword('orange'),
  error: chalk.bold.red.bgBlack
};
 
console.log(theme.success('Операция выполнена успешно!'));

const boxen = require('boxen');
const Table = require('cli-table3');
 
// Создание рамки
console.log(boxen('CLI-инструмент успешно настроен!', {
  padding: 1,
  margin: 1,
  borderStyle: 'round',
  borderColor: 'green'
}));
 
// Создание таблицы
const table = new Table({
  head: ['Команда', 'Описание'],
  colWidths: [20, 50]
});
 
table.push(
  ['init', 'Инициализация проекта'],
  ['build', 'Сборка проекта'],
  ['deploy', 'Деплой проекта']
);
 
console.log(table.toString());

const i18n = require('i18n');
const path = require('path');
 
i18n.configure({
  locales: ['en', 'ru', 'es'],
  directory: path.join(__dirname, 'locales'),
  defaultLocale: 'en',
  objectNotation: true
});
 
// Использование
console.log(i18n.__('welcome.message')); // Выводит сообщение на текущем языке

const omelette = require('omelette');
 
// Создание автодополнения
const completion = omelette('my-tool <command> <subcommand>');
 
// Настройка подсказок
completion.on('command', ({ reply }) => {
  reply(['init', 'build', 'deploy', 'test']);
});
 
completion.on('subcommand', ({ reply, command }) => {
  if (command === 'deploy') {
    reply(['prod', 'staging', 'dev']);
  } else {
    reply([]);
  }
});
 
// Инициализация
completion.init();
 
// Добавить в документацию инструкцию по установке
if (process.argv.includes('--completion')) {
  console.log(completion.getCompletionCode());
}

// Promise chaining
function processFileChain(filePath) {
  return readFile(filePath)
    .then(content => parseData(content))
    .then(data => transformData(data))
    .then(transformed => writeOutput(transformed))
    .catch(error => {
      console.error('Ошибка обработки:', error);
      process.exit(1);
    });
}
 
// Async/await
async function processFileAsync(filePath) {
  try {
    const content = await readFile(filePath);
    const data = await parseData(content);
    const transformed = await transformData(data);
    await writeOutput(transformed);
  } catch (error) {
    console.error('Ошибка обработки:', error);
    process.exit(1);
  }
}

async function processMultipleFiles(filePaths) {
  // Параллельная обработка файлов
  const results = await Promise.all(
    filePaths.map(async filePath => {
      const content = await readFile(filePath);
      return processContent(content);
    })
  );
 
  return results;
}

const pLimit = require('p-limit');
 
async function processLargeNumberOfFiles(filePaths) {
  // Ограничиваем количество одновременных операций
  const limit = pLimit(5); // Максимум 5 параллельных операций
  
  const tasks = filePaths.map(filePath => {
    return limit(() => processFile(filePath));
  });
  
  return Promise.all(tasks);
}

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
 
class FileCache {
  constructor(cacheDir = '.cache') {
    this.cacheDir = cacheDir;
    if (!fs.existsSync(cacheDir)) {
      fs.mkdirSync(cacheDir, { recursive: true });
    }
  }
  
  getCacheKey(data) {
    return crypto.createHash('md5').update(JSON.stringify(data)).digest('hex');
  }
  
  async getOrCompute(key, computeFn) {
    const cacheKey = this.getCacheKey(key);
    const cachePath = path.join(this.cacheDir, cacheKey);
    
    if (fs.existsSync(cachePath)) {
      return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
    }
    
    const result = await computeFn();
    fs.writeFileSync(cachePath, JSON.stringify(result));
    return result;
  }
}
 
// Использование
const cache = new FileCache();
 
async function processWithCache(filePath, options) {
  return cache.getOrCompute(
    { filePath, options, mtime: fs.statSync(filePath).mtime.getTime() },
    async () => {
      // Тут дорогостоящие вычисления
      return processData(await readFile(filePath), options);
    }
  );
}

const fs = require('fs');
const { Transform } = require('stream');
 
function processLargeFile(inputPath, outputPath, transformer) {
  const readStream = fs.createReadStream(inputPath, { highWaterMark: 64 * 1024 });
  const writeStream = fs.createWriteStream(outputPath);
  const transformStream = new Transform({
    transform(chunk, encoding, callback) {
      try {
        const processed = transformer(chunk.toString());
        callback(null, processed);
      } catch (err) {
        callback(err);
      }
    }
  });
 
  return new Promise((resolve, reject) => {
    readStream
      .pipe(transformStream)
      .pipe(writeStream)
      .on('finish', resolve)
      .on('error', reject);
  });
}

function lazyLoad(modulePath) {
  let module;
  return () => {
    if (!module) {
      module = require(modulePath);
    }
    return module;
  };
}
 
// Используем только при необходимости
const getParser = lazyLoad('./parser');
 
function processIfNeeded(text, shouldParse) {
  if (shouldParse) {
    const parser = getParser();
    return parser.parse(text);
  }
  return text;
}

function setupGracefulShutdown(cleanup) {
  let shuttingDown = false;
  
  process.on('SIGINT', async () => {
    if (shuttingDown) process.exit(1);
    
    shuttingDown = true;
    console.log('\nЗавершение работы...');
    
    try {
      await cleanup();
      console.log('Ресурсы освобождены. До свидания!');
      process.exit(0);
    } catch (err) {
      console.error('Ошибка при завершении:', err);
      process.exit(1);
    }
  });
}

program
  .name('my-tool')
  .description('Мощная CLI-утилита для обработки данных')
  .version('1.0.0')
  .addHelpText('after', `
Примеры:
  $ my-tool transform input.json --output result.json
  $ my-tool serve --port 3000`);

const Analytics = require('./analytics');
 
// Конфигурация с возможностью отключения
const config = new Conf();
const analyticsEnabled = config.get('analytics-enabled', true);
 
async function trackCommand(command, options) {
  if (!analyticsEnabled) return;
  
  try {
    const analytics = new Analytics({
      projectId: 'my-cli-tool',
      version: require('../package.json').version
    });
    
    await analytics.track({
      event: 'command',
      properties: {
        command,
        // НЕ включайте личные данные или аргументы
        hasOptions: Object.keys(options).length > 0,
        nodeVersion: process.version
      }
    });
  } catch (error) {
    // Тихая обработка — сбой аналитики не должен влиять на работу инструмента
  }
}

const updateNotifier = require('update-notifier');
const pkg = require('./package.json');
 
function checkForUpdates() {
  updateNotifier({
    pkg,
    updateCheckInterval: 1000 * 60 * 60 * 24 // 1 день
  }).notify({
    message: 'Доступна новая версия {currentVersion} → {latestVersion}.\nЗапустите npm i -g {packageName} для обновления'
  });
}