export async function run() {
  const options = commandLineArgs(optionDefinitions) as CliOptions;

  if (options['help']) {
    const getUsage = require('command-line-usage');
    const usage = getUsage([
      {
        header: 'modulizer',
        content: `Convert HTML Imports to JavaScript modules

If no GitHub repository names are given, modulizer converts the current
directory as a package. If repositories are provided, they are cloned into a
workspace directory as sibling folders as they would be in a Bower
installation.
`,
      },
      {
        header: 'Options',
        optionList: optionDefinitions,
      }
    ]);
    console.log(usage);
    return;
  }

  if (options['version']) {
    console.log(require('../../package.json').version);
    return;
  }

  if (options['repo']) {
    await runWorkspaceCommand(options);
    return;
  }

  const importStyle = options['import-style'];
  if (importStyle !== 'name' && importStyle !== 'path') {
    throw new Error(
        `import-style "${importStyle}" not supported. ` +
        `Supported styles: "name", "path".`);
  }

  const packageType = options['package-type'];
  if (packageType !== 'element' && packageType !== 'application') {
    throw new Error(
        `package-type "${packageType}" is not supported. ` +
        `Supported types: "element", "application".`);
  }

  await runPackageCommand(options);
}

  output (output: Output, params: { command?: string }) {
    const config   = this.cliService.getConfig();
    const programs = this.cliService.getPrograms();

    if (params.command) {
      const command = this.cliService.getCommand(params.command);

      if (!command) {
        return output.error(`Unknown command "${params.command}".`);
      }

      return output.addData(commandLineUsage(this.renderUsage(command)));
    }

    const sections: { [ key: string ]: any } = [
      { header: config.title, content: `{italic ${config.subtitle}}` },
      {
        header: chalk.yellow('Available commands:'),
      },
    ];

    const collectedExamples: string[] = [];

    Object.values(programs).forEach(({ program, commands, examples }: ProcessedProgramType) => {
      sections.push({ content: chalk.yellow(program), raw: true });
      sections.push({ content: Object.keys(commands).map((command: string) => this.renderCommand(commands[ command ])) });

      if (Array.isArray(examples)) {
        collectedExamples.push(...examples);
      }
    });

    if (collectedExamples) {
      sections.push(this.renderExamples(collectedExamples));
    }

    output.addData(commandLineUsage(sections));
  }

function usage(targetLanguages: TargetLanguage[]) {
    const rendererSections: UsageSection[] = [];

    for (const language of targetLanguages) {
        const definitions = language.cliOptionDefinitions.display;
        if (definitions.length === 0) continue;

        rendererSections.push({
            header: `Options for ${language.displayName}`,
            optionList: definitions,
            tableOptions: tableOptionsForOptions
        });
    }

    const sections = _.concat(makeSectionsBeforeRenderers(targetLanguages), rendererSections, sectionsAfterRenderers);

    console.log(getUsage(sections));
}