How to use cac - 10 common examples

const cac = require('cac')
const updateNotifier = require('update-notifier')
const Poi = require('../lib')
const isPath = require('../lib/utils/isPath')
const pkg = require('../package')

require('loud-rejection')()

updateNotifier({ pkg }).notify()

// To start Poi, we will need to know which `command` you're calling
// And you can also supply options via CLI flags
const { input, flags } = cac.parse(process.argv.slice(2))

// Handle `--version` before starting Poi
if (flags.version || flags.v) {
  console.log(require('../package').version)
  process.exit()
}

// Get command from CLI input
// When there's no input or the first element of input is a file path
// We think you're in the `develop` command
// Otherwise you're in the `input[0]` command
// And the rest of input becomes the webpack `entry`
let command
let entry
if (!input[0] || isPath(input[0])) {
  command = 'develop'

/* eslint-disable unicorn/no-process-exit */
import cac from 'cac'
import update from 'update-notifier'
import bili from './bili'
import { handleRollupError } from './utils'

const cli = cac()

update({ pkg: cli.pkg }).notify()

cli
  .option('config', {
    desc: 'Path to config file',
    alias: 'c'
  })
  .option('watch', {
    desc: 'Run in watch mode',
    alias: 'w'
  })
  .option('filename', {
    desc: 'The filename of output file, no extension',
    alias: 'n'
  })

import cac from 'cac'
import JoyCon from 'joycon'
import fs from 'fs-extra'
import { BabelParserPlugins } from '@vuese/parser'
import Log from 'log-horizon'
import preview from './preview'
import genDocute from './genDocute'
import genMarkdown from './genMarkdown'
import server from './server'

// Gotta fix after https://github.com/tabrindle/envinfo/pull/105 gets merged (type-definitions)
const envinfo = require('envinfo')

const logger = Log.create()
const cli = cac()
const joycon = new JoyCon({
  packageKey: 'vuese'
})
joycon.addLoader({
  test: /\.vueserc$/,
  async load(filePath) {
    const source = await fs.readFile(filePath, 'utf-8')
    return JSON.parse(source)
  }
})

export type CliOptions = {
  include: string | string[]
  exclude: string | string[]
  outDir: string
  markdownDir: string

#!/usr/bin/env node
if (parseInt(process.versions.node, 10) < 8) {
  const chalk = require('chalk')
  console.error(
    chalk.red(
      `Peco requires Node.js version >= 8, please upgrade!\nCheck out ${chalk.underline(
        'https://nodejs.org'
      )}`
    )
  )
  process.exit(1)
}

const cac = require('cac').default

const cli = cac()

cli
  .command('dev', 'Develop website locally', (input, flags) => {
    const app = require('../lib')(Object.assign({ baseDir: input[0] }, flags))

    return app.dev()
  })
  .option('port', {
    desc: 'Port for dev server',
    type: 'number'
  })

cli.command('build', 'Build website to static HTML files', (input, flags) => {
  const app = require('../lib')(Object.assign({ baseDir: input[0] }, flags))

  return app.build()

#!/usr/bin/env node
const cac = require('cac').default
const pkg = require('../package')

const { input, flags } = cac.parse(process.argv.slice(2))

if (flags.version || flags.v) {
  console.log(pkg.version)
  process.exit()
}

const {
  config: configFile,
  baseDir,
  inspectWebpack,
  progress,
  debug,
  debugTrace,
  cleanOutDir,
  jsx,
  clearConsole,

#!/usr/bin/env node
import fs from 'fs'
import cac from 'cac'

const cli = cac()

cli.command('*', {
  desc: 'Take a snapshot',
  examples: [
    'taki https://google.com --output out.html',
    'taki https://vuejs.org --block-cross-origin --verbose'
  ]
}, async (input, flags) => {
  if (input.length === 0) return cli.showHelp()
  const url = input[0]
  const options = {
    url: /^https?:\/\//.test(url) ? url : `http://${url}`,
    ...flags
  }

  if (flags.verbose) {

if (nodeModulePaths) {
    Module._nodeModulePaths = (...args) => {
      let paths = nodeModulePaths.apply(Module, args)
      if (Array.isArray(paths)) {
        paths.push(globalFoyPath)
      }
      return paths
    }
  }
}

for (const file of foyFiles) {
  require(file)
}

const taskCli = cac()

let taskManager = getGlobalTaskManager()
taskManager.getTasks().forEach(t => {
  let strict = taskManager.globalOptions.strict || t.strict
  let cmd = taskCli.command(t.name, t.desc, { allowUnknownOptions: !strict })
  if (t.optionDefs) {
    t.optionDefs.forEach(def => cmd.option(...def))
  }
  cmd.action(async (...args) => {
    let options = args.pop()
    let { globalOptions } = taskManager
    globalOptions.rawArgs = taskCli.rawArgs
    globalOptions.options = options
    if (globalOptions.before) {
      await globalOptions.before()
    }

#!/usr/bin/env node
import cac from 'cac'
import Bili from '.'

const cli = cac()

cli
  .command('*', 'Bundle library', async (input, flags) => {
    const options = {
      input,
      ...flags
    }
    if (options.input.length === 0) {
      delete options.input
    }
    if (options.debug) {
      options.logLevel = 4
    } else if (options.quiet) {
      options.logLevel = 1
    }
    Bili.write(options).catch(Bili.handlError)

#!/usr/bin/env node
import 'v8-compile-cache'
import cac from 'cac'
import { version } from '../package.json'

if (process.env.BILI_LOCAL_PROFILE) {
  const requireSoSlow = require('require-so-slow')
  process.on('exit', () => {
    requireSoSlow.write('require-trace.trace')
  })
}

const cli = cac('bili')

cli
  .command('[...input]', 'Bundle input files', {
    ignoreOptionDefaultValue: true
  })
  .option('-w, --watch', 'Watch files')
  .option(
    '--format ',
    'Output format (cjs | umd | es  | iife), can be used multiple times'
  )
  .option('--input.* [file]', 'An object mapping names to entry points')
  .option('-d, --out-dir ', 'Output directory', { default: 'dist' })
  .option('--root-dir ', 'The root directory to resolve files from')
  .option('--file-name ', 'Set the file name for output files')
  .option('--module-name ', 'Set the module name for umd bundle')
  .option('--env.* [value]', 'Replace env variables')

#!/usr/bin/env node
import fs from 'fs-extra'
import cac from 'cac'
import globby from 'globby'
import chalk from 'chalk'
import { parse } from '.'

const cli = cac()

cli
  .option('apiOnly', {
    desc: 'Only show APIs like Promise',
    type: 'boolean'
  })
  .option('dedupe', {
    desc: 'Remove duplicated warnings for the same feature',
    type: 'boolean'
  })

cli.command('*', {
  desc: 'Detect from input files',
  examples: [
    `${chalk.cyan(cli.bin)} "dist/**/*.js"`,
    `${chalk.cyan(cli.bin)} "src/*.js" --dedupe`,