@teambit/cli 0.0.838 → 0.0.840

package/cli-parser.ts

@@ -0,0 +1,296 @@
+import didYouMean from 'didyoumean';
+import yargs from 'yargs';
+import { Command } from '@teambit/legacy/dist/cli/command';
+import { GroupsType } from '@teambit/legacy/dist/cli/command-groups';
+import { compact } from 'lodash';
+import { loadConsumerIfExist } from '@teambit/legacy/dist/consumer';
+import logger from '@teambit/legacy/dist/logger/logger';
+import loader from '@teambit/legacy/dist/cli/loader';
+import chalk from 'chalk';
+import { getCommandId } from './get-command-id';
+import { formatHelp } from './help';
+import { GLOBAL_GROUP, STANDARD_GROUP, YargsAdapter } from './yargs-adapter';
+import { CommandNotFound } from './exceptions/command-not-found';
+
+export class CLIParser {
+  public parser = yargs;
+  constructor(private commands: Command[], private groups: GroupsType) {}
+
+  async parse(args = process.argv.slice(2)) {
+    this.throwForNonExistsCommand(args[0]);
+    logger.debug(`[+] CLI-INPUT: ${args.join(' ')}`);
+    logger.writeCommandHistoryStart();
+    yargs(args);
+    yargs.help(false);
+    this.configureParser();
+    this.commands.forEach((command: Command) => {
+      if (command.commands && command.commands.length) {
+        this.parseCommandWithSubCommands(command);
+      } else {
+        const yargsCommand = this.getYargsCommand(command);
+        yargs.command(yargsCommand);
+      }
+    });
+    this.configureGlobalFlags();
+    this.setHelpMiddleware();
+    this.handleCommandFailure();
+    this.configureCompletion();
+    yargs.strict(); // don't allow non-exist flags and non-exist commands
+
+    yargs
+      // .recommendCommands() // don't use it, it brings the global help of yargs, we have a custom one
+      .wrap(null);
+
+    await yargs.parse();
+  }
+
+  private setHelpMiddleware() {
+    yargs.middleware((argv) => {
+      if (argv._.length === 0 && argv.help) {
+        const shouldShowInternalCommands = Boolean(argv.internal);
+        // this is the main help page
+        this.printHelp(shouldShowInternalCommands);
+        process.exit(0);
+      }
+      if (argv.help) {
+        loader.off(); // stop the "loading bit..." before showing help if needed
+        // this is a command help page
+        yargs.showHelp(this.logCommandHelp.bind(this));
+        if (!logger.isDaemon) process.exit(0);
+      }
+    }, true);
+  }
+
+  private handleCommandFailure() {
+    yargs.fail((msg, err) => {
+      loader.stop();
+      if (err) {
+        throw err;
+      }
+      yargs.showHelp(this.logCommandHelp.bind(this));
+      const args = process.argv.slice(2);
+      const isHelpFlagEntered = args.includes('--help') || args.includes('-h');
+      const isMsgAboutMissingArgs = msg.startsWith('Not enough non-option arguments');
+      // avoid showing the "Not enough non-option arguments" message when the user is trying to get the command help
+      if (!isMsgAboutMissingArgs || !isHelpFlagEntered) {
+        // eslint-disable-next-line no-console
+        console.log(`\n${chalk.yellow(msg)}`);
+      }
+      if (!logger.isDaemon) process.exit(1);
+    });
+  }
+
+  private configureCompletion() {
+    const commandsToShowComponentIdsForCompletion = [
+      'show',
+      'diff',
+      'tag',
+      'export',
+      'env',
+      'envs',
+      'compile',
+      'build',
+      'test',
+      'lint',
+      'log',
+      'dependents',
+      'dependencies',
+    ];
+    // @ts-ignore
+    yargs.completion('completion', async function (current, argv, completionFilter, done) {
+      if (!current.startsWith('-') && commandsToShowComponentIdsForCompletion.includes(argv._[1])) {
+        const consumer = await loadConsumerIfExist();
+        done(consumer?.bitmapIdsFromCurrentLane.map((id) => id.toStringWithoutVersion()));
+      } else {
+        completionFilter();
+      }
+    });
+  }
+
+  private printHelp(shouldShowInternalCommands = false) {
+    const help = formatHelp(this.commands, this.groups, shouldShowInternalCommands);
+    // eslint-disable-next-line no-console
+    console.log(help);
+  }
+
+  private configureParser() {
+    yargs.parserConfiguration({
+      // 'strip-dashed': true, // we can't enable it, otherwise, the completion doesn't work
+      'strip-aliased': true,
+      'boolean-negation': false,
+      'populate--': true,
+    });
+  }
+
+  private parseCommandWithSubCommands(command: Command) {
+    const yarnCommand = this.getYargsCommand(command);
+    const builderFunc = () => {
+      command.commands?.forEach((cmd) => {
+        const subCommand = this.getYargsCommand(cmd);
+        yargs.command(subCommand);
+      });
+      // since the "builder" method is overridden, the global flags of the main command are gone, this fixes it.
+      yargs.options(YargsAdapter.getGlobalOptions(command));
+      return yargs;
+    };
+    yarnCommand.builder = builderFunc;
+    yargs.command(yarnCommand);
+  }
+
+  private getYargsCommand(command: Command): YargsAdapter {
+    const yarnCommand = new YargsAdapter(command);
+    yarnCommand.builder = yarnCommand.builder.bind(yarnCommand);
+    yarnCommand.handler = yarnCommand.handler.bind(yarnCommand);
+
+    return yarnCommand;
+  }
+
+  private configureGlobalFlags() {
+    yargs
+      .option('help', {
+        alias: 'h',
+        describe: 'show help',
+        group: GLOBAL_GROUP,
+      })
+      .option('version', {
+        global: false,
+        alias: 'v',
+        describe: 'show version',
+        group: GLOBAL_GROUP,
+      });
+  }
+
+  private throwForNonExistsCommand(commandName: string) {
+    if (!commandName || commandName.startsWith('-')) {
+      return;
+    }
+    const commandsNames = this.commands.map((c) => getCommandId(c.name));
+    const aliases = this.commands.map((c) => c.alias).filter((a) => a);
+    const existingGlobalFlags = ['-V', '--version'];
+    const validCommands = [...commandsNames, ...aliases, ...existingGlobalFlags];
+    const commandExist = validCommands.includes(commandName);
+
+    if (!commandExist) {
+      didYouMean.returnFirstMatch = true;
+      const suggestions = didYouMean(
+        commandName,
+        this.commands.filter((c) => !c.private).map((c) => getCommandId(c.name))
+      );
+      const suggestion = suggestions && Array.isArray(suggestions) ? suggestions[0] : suggestions;
+
+      throw new CommandNotFound(commandName, suggestion as string);
+    }
+  }
+
+  /**
+   * manipulate the command help output. there is no API from Yarn to do any of this, so it needs to be done manually.
+   * see https://github.com/yargs/yargs/issues/1956
+   *
+   * the original order of the output:
+   * description
+   * Options
+   * Commands
+   * Global
+   * Positionals
+   * Examples
+   */
+  private logCommandHelp(help: string) {
+    const command = this.findCommandByArgv();
+
+    const replacer = (_, p1, p2) => `${p1}${chalk.green(p2)}`;
+    const lines = help.split('\n');
+    const linesWithoutEmpty = compact(lines);
+    const cmdLine = linesWithoutEmpty[0];
+    const description: string[] = [];
+    const options: string[] = [];
+    const globalOptions: string[] = [];
+    const subCommands: string[] = [];
+    const args: string[] = [];
+    const examples: string[] = [];
+
+    let optionsStarted = false;
+    let globalStarted = false;
+    let subCommandsStarted = false;
+    let positionalsStarted = false;
+    let examplesStarted = false;
+    for (let i = 1; i < linesWithoutEmpty.length; i += 1) {
+      const currentLine = linesWithoutEmpty[i];
+      if (currentLine === STANDARD_GROUP) {
+        optionsStarted = true;
+      } else if (currentLine === GLOBAL_GROUP) {
+        globalStarted = true;
+      } else if (currentLine === 'Commands:') {
+        subCommandsStarted = true;
+      } else if (currentLine === 'Positionals:') {
+        positionalsStarted = true;
+      } else if (currentLine === 'Examples:') {
+        examplesStarted = true;
+      } else if (examplesStarted) {
+        examples.push(currentLine);
+      } else if (positionalsStarted) {
+        args.push(currentLine);
+      } else if (globalStarted) {
+        globalOptions.push(currentLine);
+      } else if (optionsStarted) {
+        options.push(currentLine);
+      } else if (subCommandsStarted) {
+        subCommands.push(currentLine);
+      } else {
+        description.push(currentLine);
+      }
+    }
+
+    // show the flags in green
+    const optionsColored = options.map((opt) => opt.replace(/(--)([\w-]+)/, replacer).replace(/(-)([\w-]+)/, replacer));
+    const argsColored = args.map((arg) => arg.replace(/^ {2}\S+/, (argName) => chalk.green(argName))); // regex: two spaces then the first word until a white space
+    const optionsStr = options.length ? `\n${STANDARD_GROUP}\n${optionsColored.join('\n')}\n` : '';
+    const argumentsStr = args.length ? `\nArguments:\n${argsColored.join('\n')}\n` : '';
+    const examplesStr = examples.length ? `\nExamples:\n${examples.join('\n')}\n` : '';
+    const subCommandsStr = subCommands.length ? `\n${'Commands:'}\n${subCommands.join('\n')}\n` : '';
+    // show the description in bold
+    const descriptionColored = description.map((desc) => chalk.bold(desc));
+    if (command?.extendedDescription) {
+      descriptionColored.push(command?.extendedDescription);
+    }
+    if (command?.helpUrl) {
+      descriptionColored.push(`for more info, visit: ${chalk.underline(command.helpUrl)}`);
+    }
+    const descriptionStr = descriptionColored.join('\n');
+    const globalOptionsStr = globalOptions.join('\n');
+
+    const finalOutput = `${cmdLine}
+
+${descriptionStr}
+${argumentsStr}${subCommandsStr}${optionsStr}${examplesStr}
+${GLOBAL_GROUP}
+${globalOptionsStr}`;
+
+    // eslint-disable-next-line no-console
+    console.log(finalOutput);
+  }
+
+  private findCommandByArgv(): Command | undefined {
+    const args = process.argv.slice(2);
+    const enteredCommand = args[0];
+    const enteredSubCommand = args[1];
+    if (!enteredCommand) {
+      return undefined;
+    }
+    const isCommandMatch = (cmd: Command, str: string) => {
+      return (
+        cmd.name.startsWith(`${str} `) || // e.g. "tag <id>".startsWith("tag ")
+        cmd.name === str || // e.g. "globals" === "globals"
+        cmd.alias === str
+      ); // e.g. "t" === "t"
+    };
+    const command = this.commands.find((cmd) => isCommandMatch(cmd, enteredCommand));
+    if (!command) {
+      return undefined;
+    }
+    if (!command.commands || !enteredSubCommand) {
+      return command; // no sub-commands.
+    }
+    const subCommand = command.commands.find((cmd) => isCommandMatch(cmd, enteredSubCommand));
+    return subCommand || command;
+  }
+}

package/cli.aspect.ts

@@ -0,0 +1,11 @@
+import { Aspect, RuntimeDefinition } from '@teambit/harmony';
+
+export const MainRuntime = new RuntimeDefinition('main');
+
+export const CLIAspect = Aspect.create({
+  id: 'teambit.harmony/cli',
+  dependencies: [],
+  declareRuntime: MainRuntime,
+});
+
+export default CLIAspect;

package/cli.cmd.ts

@@ -0,0 +1,110 @@
+// eslint-disable-next-line max-classes-per-file
+import { Command, CommandOptions } from '@teambit/cli';
+import legacyLogger from '@teambit/legacy/dist/logger/logger';
+import { handleErrorAndExit } from '@teambit/legacy/dist/cli/handle-errors';
+import { loadConsumerIfExist } from '@teambit/legacy/dist/consumer';
+import { getHarmonyVersion } from '@teambit/legacy/dist/bootstrap';
+import readline from 'readline';
+import { CLIParser } from './cli-parser';
+import { CLIMain } from './cli.main.runtime';
+import { GenerateCommandsDoc, GenerateOpts } from './generate-doc-md';
+
+export class CliGenerateCmd implements Command {
+  name = 'generate';
+  description = 'generate an .md file with all commands details';
+  alias = '';
+  loader = false;
+  group = 'general';
+  options = [
+    [
+      '',
+      'metadata',
+      'metadata/front-matter to place at the top of the .md file, enter as an object e.g. --metadata.id=cli --metadata.title=commands',
+    ],
+    ['', 'docs', 'generate the cli-reference.docs.mdx file'],
+    ['j', 'json', 'output the commands info as JSON'],
+  ] as CommandOptions;
+
+  constructor(private cliMain: CLIMain) {}
+
+  async report(args, { metadata, docs }: GenerateOpts & { docs?: boolean }): Promise<string> {
+    if (docs) {
+      return `---
+description: 'Bit command synopses. Bit version: ${getHarmonyVersion()}'
+labels: ['cli', 'mdx', 'docs']
+---
+      `;
+    }
+    return new GenerateCommandsDoc(this.cliMain.commands, { metadata }).generate();
+  }
+
+  async json() {
+    return new GenerateCommandsDoc(this.cliMain.commands, {}).generateJson();
+  }
+}
+
+export class CliCmd implements Command {
+  name = 'cli';
+  description = 'EXPERIMENTAL. enters bit cli program and generates commands list';
+  alias = '';
+  commands: Command[] = [];
+  loader = false;
+  group = 'general';
+  options = [] as CommandOptions;
+
+  constructor(private cliMain: CLIMain) {}
+
+  async report(): Promise<string> {
+    legacyLogger.isDaemon = true;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: 'bit > ',
+      completer: (line, cb) => completer(line, cb, this.cliMain),
+    });
+
+    const cliParser = new CLIParser(this.cliMain.commands, this.cliMain.groups);
+
+    rl.prompt();
+
+    return new Promise((resolve) => {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      rl.on('line', async (line) => {
+        const cmd = line.trim().split(' ');
+        try {
+          await cliParser.parse(cmd);
+        } catch (err: any) {
+          await handleErrorAndExit(err, cmd[0]);
+        }
+        rl.prompt();
+      }).on('close', () => {
+        resolve('Have a great day!');
+      });
+    });
+  }
+}
+
+function completer(line: string, cb: Function, cliMain: CLIMain) {
+  const lineSplit = line.split(' ');
+  let values: string[] = [];
+  if (lineSplit.length <= 1) {
+    values = completeCommand(line, cliMain);
+    cb(null, [values, line]);
+  }
+  loadConsumerIfExist()
+    .then((consumer) => {
+      const comps = consumer?.bitmapIdsFromCurrentLane.map((id) => id.toStringWithoutVersion()) || [];
+      values = comps.filter((c) => c.includes(lineSplit[1]));
+      // eslint-disable-next-line promise/no-callback-in-promise
+      cb(null, [values, line]);
+    })
+    .catch((err) => {
+      // eslint-disable-next-line promise/no-callback-in-promise
+      cb(err, [[], line]);
+    });
+}
+
+function completeCommand(line: string, cliMain: CLIMain): string[] {
+  const commands = cliMain.commands.filter((cmd) => cmd.name.startsWith(line));
+  return commands.map((c) => c.name).map((name) => name.split(' ')[0]);
+}

package/cli.main.runtime.ts

@@ -0,0 +1,193 @@
+import { Slot, SlotRegistry } from '@teambit/harmony';
+import { buildRegistry } from '@teambit/legacy/dist/cli';
+import legacyLogger from '@teambit/legacy/dist/logger/logger';
+import { Command } from '@teambit/legacy/dist/cli/command';
+import pMapSeries from 'p-map-series';
+import { groups, GroupsType } from '@teambit/legacy/dist/cli/command-groups';
+import { loadConsumerIfExist } from '@teambit/legacy/dist/consumer';
+import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
+import { clone } from 'lodash';
+import { CLIAspect, MainRuntime } from './cli.aspect';
+import { getCommandId } from './get-command-id';
+import { LegacyCommandAdapter } from './legacy-command-adapter';
+import { CLIParser } from './cli-parser';
+import { CompletionCmd } from './completion.cmd';
+import { CliCmd, CliGenerateCmd } from './cli.cmd';
+import { HelpCmd } from './help.cmd';
+import { VersionCmd } from './version.cmd';
+
+export type CommandList = Array<Command>;
+export type OnStart = (hasWorkspace: boolean, currentCommand: string) => Promise<void>;
+export type OnBeforeExitFn = () => Promise<void>;
+
+export type OnStartSlot = SlotRegistry<OnStart>;
+export type CommandsSlot = SlotRegistry<CommandList>;
+export type OnBeforeExitSlot = SlotRegistry<OnBeforeExitFn>;
+
+export class CLIMain {
+  public groups: GroupsType = clone(groups); // if it's not cloned, it is cached across loadBit() instances
+  constructor(
+    private commandsSlot: CommandsSlot,
+    private onStartSlot: OnStartSlot,
+    private onBeforeExitSlot: OnBeforeExitSlot,
+    private logger: Logger
+  ) {}
+
+  /**
+   * registers a new command in to the CLI.
+   */
+  register(...commands: CommandList) {
+    commands.forEach((command) => {
+      this.setDefaults(command);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      command.commands!.forEach((cmd) => this.setDefaults(cmd));
+    });
+    this.commandsSlot.register(commands);
+  }
+
+  /**
+   * helpful for having the same command name in different environments (e.g. legacy and non-legacy).
+   * for example `cli.unregister('tag');` removes the "bit tag" command.
+   */
+  unregister(commandName: string) {
+    this.commandsSlot.toArray().forEach(([aspectId, commands]) => {
+      const filteredCommands = commands.filter((command) => {
+        return getCommandId(command.name) !== commandName;
+      });
+      this.commandsSlot.map.set(aspectId, filteredCommands);
+    });
+  }
+
+  /**
+   * list of all registered commands. (legacy and new).
+   */
+  get commands(): CommandList {
+    return this.commandsSlot.values().flat();
+  }
+
+  /**
+   * get an instance of a registered command. (useful for aspects to modify and extend existing commands)
+   */
+  getCommand(name: string): Command | undefined {
+    return this.commands.find((command) => getCommandId(command.name) === name);
+  }
+
+  /**
+   * when running `bit help`, commands are grouped by categories.
+   * this method helps registering a new group by providing its name and a description.
+   * the name is what needs to be assigned to the `group` property of the Command interface.
+   * the description is what shown in the `bit help` output.
+   */
+  registerGroup(name: string, description: string) {
+    if (this.groups[name]) {
+      this.logger.consoleWarning(`CLI group "${name}" is already registered`);
+    } else {
+      this.groups[name] = description;
+    }
+  }
+
+  registerOnStart(onStartFn: OnStart) {
+    this.onStartSlot.register(onStartFn);
+    return this;
+  }
+
+  /**
+   * This will register a function to be called before the process exits.
+   * This will run only for "regular" exits
+   * e.g.
+   * yes - command run and finished successfully
+   * yes - command run and failed gracefully (code 1)
+   * not SIGKILL (kill -9)
+   * not SIGINT (Ctrl+C)
+   * not SIGTERM (kill)
+   * not uncaughtException
+   * not unhandledRejection
+   *
+   * @param onBeforeExitFn
+   * @returns
+   */
+  registerOnBeforeExit(onBeforeExitFn: OnBeforeExitFn) {
+    this.onBeforeExitSlot.register(onBeforeExitFn);
+    legacyLogger.registerOnBeforeExitFn(onBeforeExitFn);
+    return this;
+  }
+
+  /**
+   * execute commands registered to this aspect.
+   */
+  async run(hasWorkspace: boolean) {
+    await this.invokeOnStart(hasWorkspace);
+    const CliParser = new CLIParser(this.commands, this.groups);
+    await CliParser.parse();
+  }
+
+  private async invokeOnStart(hasWorkspace: boolean) {
+    const onStartFns = this.onStartSlot.values();
+    const currentCommand = process.argv[2];
+    await pMapSeries(onStartFns, (onStart) => onStart(hasWorkspace, currentCommand));
+  }
+
+  private setDefaults(command: Command) {
+    command.alias = command.alias || '';
+    command.description = command.description || '';
+    command.extendedDescription = command.extendedDescription || '';
+    command.group = command.group || 'ungrouped';
+    command.options = command.options || [];
+    command.private = command.private || false;
+    command.commands = command.commands || [];
+    command.name = command.name.trim();
+    if (command.loader === undefined) {
+      if (command.internal) {
+        command.loader = false;
+      } else {
+        command.loader = true;
+      }
+    }
+    if (command.helpUrl && !isFullUrl(command.helpUrl)) {
+      command.helpUrl = `https://bit.dev/${command.helpUrl}`;
+    }
+  }
+
+  static dependencies = [LoggerAspect];
+  static runtime = MainRuntime;
+  static slots = [Slot.withType<CommandList>(), Slot.withType<OnStart>(), Slot.withType<OnBeforeExitFn>()];
+
+  static async provider(
+    [loggerMain]: [LoggerMain],
+    config,
+    [commandsSlot, onStartSlot, onBeforeExitSlot]: [CommandsSlot, OnStartSlot, OnBeforeExitSlot]
+  ) {
+    const logger = loggerMain.createLogger(CLIAspect.id);
+    const cliMain = new CLIMain(commandsSlot, onStartSlot, onBeforeExitSlot, logger);
+    const legacyRegistry = buildRegistry();
+    await ensureWorkspaceAndScope();
+    const legacyCommands = legacyRegistry.commands;
+    const legacyCommandsAdapters = legacyCommands.map((command) => new LegacyCommandAdapter(command, cliMain));
+    const cliGenerateCmd = new CliGenerateCmd(cliMain);
+    const cliCmd = new CliCmd(cliMain);
+    const helpCmd = new HelpCmd(cliMain);
+    cliCmd.commands.push(cliGenerateCmd);
+    cliMain.register(...legacyCommandsAdapters, new CompletionCmd(), cliCmd, helpCmd, new VersionCmd());
+    return cliMain;
+  }
+}
+
+CLIAspect.addRuntime(CLIMain);
+
+/**
+ * kind of a hack.
+ * in the legacy, this is running at the beginning and it take care of issues when Bit files are missing,
+ * such as ".bit".
+ * (to make this process better, you can easily remove it and run the e2e-tests. you'll see some failing)
+ */
+async function ensureWorkspaceAndScope() {
+  try {
+    await loadConsumerIfExist();
+  } catch (err) {
+    // do nothing. it could fail for example with ScopeNotFound error, which is taken care of in "bit init".
+  }
+}
+
+function isFullUrl(url: string) {
+  return url.startsWith('http://') || url.startsWith('https://');
+}