@teambit/cli 0.0.386 → 0.0.390

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/cli",
-  "version": "0.0.386",
+  "version": "0.0.390",
   "homepage": "https://bit.dev/teambit/harmony/cli",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.harmony",
     "name": "cli",
-    "version": "0.0.386"
+    "version": "0.0.390"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -18,7 +18,7 @@
     "pad-right": "0.2.2",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/bit-error": "0.0.372"
+    "@teambit/bit-error": "0.0.376"
   },
   "devDependencies": {
     "@types/didyoumean": "1.2.0",
@@ -32,7 +32,7 @@
     "@types/node": "12.20.4"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.172",
+    "@teambit/legacy": "1.0.176",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -60,12 +60,27 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.172",
+        "@teambit/legacy": "1.0.176",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "**/*.md",
+    "**/*.mdx",
+    "**/*.js",
+    "**/*.json",
+    "**/*.sass",
+    "**/*.scss",
+    "**/*.less",
+    "**/*.css",
+    "**/*.css",
+    "**/*.jpeg",
+    "**/*.gif"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/tsconfig.json

@@ -15,9 +15,9 @@
     "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "outDir": "dist",
     "composite": true,
     "emitDeclarationOnly": true,
+    "outDir": "dist",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true,

package/bin/bit

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require('../dist/app');

package/cli-parser.ts

@@ -1,191 +0,0 @@
-import didYouMean from 'didyoumean';
-import yargs, { CommandModule } from 'yargs';
-import { Command } from '@teambit/legacy/dist/cli/command';
-import { GroupsType } from '@teambit/legacy/dist/cli/command-groups';
-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 {
-  constructor(private commands: Command[], private groups: GroupsType, public parser = yargs) {}
-
-  async parse(args = process.argv.slice(2)) {
-    this.throwForNonExistsCommand(args[0]);
-
-    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) {
-        // this is the main help page
-        this.printHelp();
-        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(logCommandHelp);
-        if (!logger.isDaemon) process.exit(0);
-      }
-    }, true);
-  }
-
-  private handleCommandFailure() {
-    yargs.fail((msg, err) => {
-      loader.stop();
-      if (err) {
-        throw err;
-      }
-      yargs.showHelp(logCommandHelp);
-      // 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() {
-    const help = formatHelp(this.commands, this.groups);
-    // 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);
-    yarnCommand.builder = () => {
-      command.commands?.forEach((cmd) => {
-        const subCommand = this.getYargsCommand(cmd);
-        yargs.command(subCommand);
-      });
-      return yargs;
-    };
-    yargs.command(yarnCommand);
-  }
-
-  private getYargsCommand(command: Command): CommandModule {
-    const yarnCommand = new YargsAdapter(command);
-    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);
-    }
-  }
-}
-
-/**
- * color the flags with green.
- * there is no API to get the options, so it is done by regex.
- * see https://github.com/yargs/yargs/issues/1956
- */
-function logCommandHelp(help: string) {
-  const replacer = (_, p1, p2) => `${p1}${chalk.green(p2)}`;
-  const lines = help.split('\n');
-  let passedOptions = false;
-  for (let i = 0; i < lines.length; i += 1) {
-    const line = lines[i];
-    if (line.startsWith(STANDARD_GROUP)) {
-      passedOptions = true;
-    } else if (passedOptions) {
-      lines[i] = line.replace(/(--)([\w-]+)/, replacer).replace(/(-)([\w-]+)/, replacer);
-    }
-  }
-  // eslint-disable-next-line no-console
-  console.log(lines.join('\n'));
-}

package/cli.aspect.ts

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

package/cli.cmd.ts

@@ -1,96 +0,0 @@
-// eslint-disable-next-line max-classes-per-file
-import { Command, CommandOptions } from '@teambit/cli';
-import logger from '@teambit/legacy/dist/logger/logger';
-import { handleErrorAndExit } from '@teambit/legacy/dist/cli/handle-errors';
-import { loadConsumerIfExist } from '@teambit/legacy/dist/consumer';
-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 = 'EXPERIMENTAL. 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',
-    ],
-  ] as CommandOptions;
-
-  constructor(private cliMain: CLIMain) {}
-
-  async report(args, { metadata }: GenerateOpts): Promise<string> {
-    return new GenerateCommandsDoc(this.cliMain.commands, { metadata }).generate();
-  }
-}
-
-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> {
-    logger.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

@@ -1,140 +0,0 @@
-import { Slot, SlotRegistry } from '@teambit/harmony';
-import { buildRegistry } from '@teambit/legacy/dist/cli';
-import { Command } from '@teambit/legacy/dist/cli/command';
-import LegacyLoadExtensions from '@teambit/legacy/dist/legacy-extensions/extensions-loader';
-import { groups, GroupsType } from '@teambit/legacy/dist/cli/command-groups';
-import { clone } from 'lodash';
-import { CLIAspect, MainRuntime } from './cli.aspect';
-import { AlreadyExistsError } from './exceptions/already-exists';
-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';
-
-export type CommandList = Array<Command>;
-export type OnStart = (hasWorkspace: boolean) => Promise<void>;
-
-export type OnStartSlot = SlotRegistry<OnStart>;
-export type CommandsSlot = SlotRegistry<CommandList>;
-
-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) {}
-
-  /**
-   * 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 (legacy and Harmony)
-   */
-  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();
-  }
-
-  /**
-   * 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]) {
-      throw new AlreadyExistsError('group', name);
-    }
-    this.groups[name] = description;
-  }
-
-  registerOnStart(onStartFn: OnStart) {
-    this.onStartSlot.register(onStartFn);
-    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 promises = onStartFns.map(async (onStart) => onStart(hasWorkspace));
-    return Promise.all(promises);
-  }
-
-  private setDefaults(command: Command) {
-    command.alias = command.alias || '';
-    command.description = command.description || '';
-    command.shortDescription = command.shortDescription || '';
-    command.group = command.group || 'ungrouped';
-    command.options = command.options || [];
-    command.private = command.private || false;
-    command.commands = command.commands || [];
-    if (command.loader === undefined) {
-      if (command.internal) {
-        command.loader = false;
-      } else {
-        command.loader = true;
-      }
-    }
-  }
-
-  static dependencies = [];
-  static runtime = MainRuntime;
-  static slots = [Slot.withType<CommandList>(), Slot.withType<OnStart>()];
-
-  static async provider(deps, config, [commandsSlot, onStartSlot]: [CommandsSlot, OnStartSlot]) {
-    const cliMain = new CLIMain(commandsSlot, onStartSlot);
-    const legacyExtensions = await LegacyLoadExtensions();
-    // Make sure to register all the hooks actions in the global hooks manager
-    legacyExtensions.forEach((extension) => {
-      extension.registerHookActionsOnHooksManager();
-    });
-
-    const extensionsCommands = legacyExtensions.reduce((acc, curr) => {
-      if (curr.commands && curr.commands.length) {
-        // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-        acc = acc.concat(curr.commands);
-      }
-      return acc;
-    }, []);
-
-    const legacyRegistry = buildRegistry(extensionsCommands);
-    const legacyCommands = legacyRegistry.commands.concat(legacyRegistry.extensionsCommands || []);
-    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);
-    return cliMain;
-  }
-}
-
-CLIAspect.addRuntime(CLIMain);

package/command-runner.ts

@@ -1,142 +0,0 @@
-import { render } from 'ink';
-import { migrate } from '@teambit/legacy/dist/api/consumer';
-import logger, { LoggerLevel } from '@teambit/legacy/dist/logger/logger';
-import { CLIArgs, Command, Flags, RenderResult } from '@teambit/legacy/dist/cli/command';
-import { parseCommandName } from '@teambit/legacy/dist/cli/command-registry';
-import loader from '@teambit/legacy/dist/cli/loader';
-import { handleErrorAndExit } from '@teambit/legacy/dist/cli/handle-errors';
-import { TOKEN_FLAG_NAME } from '@teambit/legacy/dist/constants';
-import globalFlags from '@teambit/legacy/dist/cli/global-flags';
-import { Analytics } from '@teambit/legacy/dist/analytics/analytics';
-
-export class CommandRunner {
-  private commandName: string;
-  constructor(private command: Command, private args: CLIArgs, private flags: Flags) {
-    this.commandName = parseCommandName(this.command.name);
-  }
-
-  /**
-   * run command using one of the handler, "json"/"report"/"render". once done, exit the process.
-   */
-  async runCommand() {
-    try {
-      this.bootstrapCommand();
-      await this.runMigrateIfNeeded();
-      this.determineConsoleWritingDuringCommand();
-      if (this.flags.json) {
-        return await this.runJsonHandler();
-      }
-      if (this.shouldRunRender()) {
-        return await this.runRenderHandler();
-      }
-      if (this.command.report) {
-        return await this.runReportHandler();
-      }
-    } catch (err: any) {
-      return handleErrorAndExit(err, this.commandName, this.command.internal);
-    }
-
-    throw new Error(`command "${this.commandName}" doesn't implement "render" nor "report" methods`);
-  }
-
-  private bootstrapCommand() {
-    Analytics.init(this.commandName, this.flags, this.args);
-    logger.info(`[*] started a new command: "${this.commandName}" with the following data:`, {
-      args: this.args,
-      flags: this.flags,
-    });
-    const token = this.flags[TOKEN_FLAG_NAME];
-    if (token) {
-      globalFlags.token = token.toString();
-    }
-  }
-
-  /**
-   * when both "render" and "report" were implemented, check whether it's a terminal.
-   * if it's a terminal, use "render", if not, use "report" because "report" is just a string
-   */
-  private shouldRunRender() {
-    const isTerminal = process.stdout.isTTY;
-    if (this.command.report && !isTerminal) {
-      return false;
-    }
-    return Boolean(this.command.render);
-  }
-
-  /**
-   * this works for both, Harmony commands and Legacy commands (the legacy-command-adapter
-   * implements json() method)
-   */
-  private async runJsonHandler() {
-    if (!this.flags.json) return null;
-    if (!this.command.json) throw new Error(`command "${this.commandName}" doesn't implement "json" method`);
-    const result = await this.command.json(this.args, this.flags);
-    const code = result.code || 0;
-    const data = result.data || result;
-    return this.writeAndExit(JSON.stringify(data, null, 2), code);
-  }
-
-  private async runRenderHandler() {
-    if (!this.command.render) throw new Error('runRenderHandler expects command.render to be implemented');
-    const result = await this.command.render(this.args, this.flags);
-    loader.off();
-
-    const { data, code } = toRenderResult(result);
-
-    const { waitUntilExit } = render(data);
-    await waitUntilExit();
-    return logger.exitAfterFlush(code, this.commandName);
-  }
-
-  private async runReportHandler() {
-    if (!this.command.report) throw new Error('runReportHandler expects command.report to be implemented');
-    const result = await this.command.report(this.args, this.flags);
-    loader.off();
-    const data = typeof result === 'string' ? result : result.data;
-    const exitCode = typeof result === 'string' ? 0 : result.code;
-    return this.writeAndExit(`${data}\n`, exitCode);
-  }
-
-  /**
-   * the loader and logger.console write output to the console during the command execution.
-   * for internals commands, such as, _put, _fetch, the command.loader = false.
-   */
-  private determineConsoleWritingDuringCommand() {
-    if (this.command.loader && !this.flags.json && !this.flags['get-yargs-completions']) {
-      loader.on();
-      loader.start(`running command "${this.commandName}"...`);
-      logger.shouldWriteToConsole = true;
-    } else {
-      loader.off();
-      logger.shouldWriteToConsole = false;
-    }
-    if (this.flags.log) {
-      const logValue = typeof this.flags.log === 'string' ? this.flags.log : undefined;
-      logger.switchToConsoleLogger(logValue as LoggerLevel);
-    }
-  }
-
-  private async writeAndExit(data: string, exitCode: number) {
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    return process.stdout.write(data, async () => logger.exitAfterFlush(exitCode, this.commandName));
-  }
-
-  private async runMigrateIfNeeded(): Promise<any> {
-    // @ts-ignore LegacyCommandAdapter has .migration
-    if (this.command.migration) {
-      logger.debug('Checking if a migration is needed');
-      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
-      return migrate(null, false);
-    }
-    return null;
-  }
-}
-
-function toRenderResult(obj: RenderResult | React.ReactElement) {
-  return isRenderResult(obj) ? obj : { data: obj, code: 0 };
-}
-
-function isRenderResult(obj: RenderResult | any): obj is RenderResult {
-  // eslint-disable-next-line no-prototype-builtins
-  return typeof obj === 'object' && typeof obj.code === 'number' && obj.hasOwnProperty('data');
-}

package/completion.cmd.ts

@@ -1,9 +0,0 @@
-import { Command } from '@teambit/legacy/dist/cli/command';
-
-export class CompletionCmd implements Command {
-  name = 'completion';
-  description = 'enable bash/zsh-completion shortcuts for commands and options';
-  alias = '';
-  group = 'general';
-  options = [];
-}

package/exceptions/already-exists.ts

@@ -1,7 +0,0 @@
-import { BitError } from '@teambit/bit-error';
-
-export class AlreadyExistsError extends BitError {
-  constructor(type: string, name: string) {
-    super(`${type} ${name} already exists.`);
-  }
-}

package/exceptions/command-not-found.ts

@@ -1,22 +0,0 @@
-import { BitError } from '@teambit/bit-error';
-import chalk from 'chalk';
-
-export class CommandNotFound extends BitError {
-  commandName: string;
-  suggestion?: string;
-  constructor(commandName: string, suggestion?: string) {
-    super(`command ${commandName} was not found`);
-    this.commandName = commandName;
-    this.suggestion = suggestion;
-  }
-  report() {
-    let output = chalk.yellow(
-      `warning: '${chalk.bold(this.commandName)}' is not a valid command.
-see 'bit help' for additional information`
-    );
-    if (this.suggestion) {
-      output += `\nDid you mean ${chalk.bold(this.suggestion)}?`;
-    }
-    return output;
-  }
-}

package/exceptions/index.ts

@@ -1 +0,0 @@
-export { AlreadyExistsError } from './already-exists';

package/generate-doc-md.ts

@@ -1,89 +0,0 @@
-import { Command } from '@teambit/legacy/dist/cli/command';
-import { CommandOptions } from '@teambit/legacy/dist/cli/legacy-command';
-import { getCommandId } from './get-command-id';
-
-export type GenerateOpts = {
-  metadata?: Record<string, string>;
-};
-export class GenerateCommandsDoc {
-  constructor(private commands: Command[], private options: GenerateOpts) {}
-
-  generate(): string {
-    const commands = this.getAllPublicCommandsSorted();
-    const metadata = {
-      id: 'cli-all',
-      title: 'CLI Commands',
-      ...this.options.metadata,
-    };
-    const metadataStr = Object.keys(metadata)
-      .map((key) => `${key}: ${metadata[key]}`)
-      .join('\n');
-    let output = `---
-${metadataStr}
----
-
-Commands that are marked as workspace only must be executed inside a workspace. Commands that are marked as not workspace only, can be executed from anywhere and will run on a remote server.
-`;
-    output += commands.map((cmd) => this.generateCommand(cmd)).join('\n');
-
-    return output;
-  }
-
-  private getAllPublicCommandsSorted() {
-    const publicCommands = this.commands.filter((cmd) => !cmd.private);
-    return publicCommands.sort((a, b) => a.name.localeCompare(b.name));
-  }
-
-  private generateCommand(cmd: Command) {
-    const commandName = getCommandId(cmd.name);
-    let result = `## ${commandName}  \n\n`;
-    if (cmd.alias && cmd.alias.length > 0) {
-      result += `**Alias**: \`${cmd.alias}\`  \n`;
-    }
-    result += `**Workspace only**: ${cmd.skipWorkspace ? 'no' : 'yes'}  \n`;
-    result += `**Description**: ${this.formatDescription(cmd.description as string)}`;
-    result += `\`bit ${cmd.name}\`  \n\n`;
-
-    if (cmd.commands && cmd.commands.length > 0) {
-      result += this.generateSubCommands(cmd.commands);
-    }
-    result += this.generateOptions(cmd.options);
-    result += `---  \n`;
-
-    return result;
-  }
-
-  private generateSubCommands(subCommands: Command[]) {
-    let ret = '';
-    subCommands.forEach((subCommand) => {
-      // @ts-ignore
-      const name = subCommand.name.match(/^([\w-]+)/)[0];
-      const usage = subCommand.name;
-      ret += `### ${name} \n`;
-      ret += `**Usage**: \`${usage}\`  \n\n`;
-      ret += `**Description**: ${this.formatDescription(subCommand.description as string)}`;
-
-      ret += '\n';
-      ret += this.generateOptions(subCommand.options);
-    });
-    return ret;
-  }
-
-  private generateOptions(options: CommandOptions): string {
-    if (!options || options.length <= 0) return '';
-    let output = `| **Option** | **Option alias** | **Description**|  \n`;
-    output += `|---|:-----:|---|\n`;
-    options.forEach((opt) => {
-      const [alias, flag, description] = opt;
-      const aliasFormatted = alias ? `\`-${alias}\`` : '   ';
-      const flagFormatted = `--${flag}`;
-      output += `|\`${flagFormatted}\`|${aliasFormatted}|${description}|\n`;
-    });
-    output += `\n`;
-    return output;
-  }
-
-  private formatDescription(description: string): string {
-    return `${description.split('\n').join('  \n')}  \n\n`;
-  }
-}

package/get-command-id.ts

@@ -1,3 +0,0 @@
-export function getCommandId(cmdName: string) {
-  return cmdName.split(' ')[0].trim();
-}

package/help.cmd.ts

@@ -1,18 +0,0 @@
-import { Command, CommandOptions } from '@teambit/cli';
-import { CLIMain } from './cli.main.runtime';
-import { formatHelp } from './help';
-
-export class HelpCmd implements Command {
-  name = 'help';
-  description = 'shows help';
-  alias = '$0'; // default command (meaning, if no args are provided, this will be used), see https://github.com/yargs/yargs/blob/master/docs/advanced.md#default-commands
-  loader = false;
-  group = 'general';
-  options = [] as CommandOptions;
-
-  constructor(private cliMain: CLIMain) {}
-
-  async report() {
-    return formatHelp(this.cliMain.commands, this.cliMain.groups);
-  }
-}

package/help.ts

@@ -1,80 +0,0 @@
-import chalk from 'chalk';
-import rightpad from 'pad-right';
-import { capitalize } from 'lodash';
-import { GroupsType } from '@teambit/legacy/dist/cli/command-groups';
-import { CommandList } from './cli.main.runtime';
-import { getCommandId } from './get-command-id';
-
-const SPACE = ' ';
-const TITLE_LEFT_SPACES_NUMBER = 2;
-const COMMAND_LEFT_SPACES_NUMBER = 4;
-const NAME_WITH_SPACES_LENGTH = 15;
-
-type HelpProps = {
-  [groupName: string]: GroupContent;
-};
-
-type GroupContent = {
-  commands: { [cmdName: string]: string };
-  description: string;
-};
-
-export function formatHelp(commands: CommandList, groups: GroupsType) {
-  const helpProps = groupCommands(commands, groups);
-  const commandsStr = formatCommandsHelp(helpProps);
-
-  return `${getHeader()}
-
-${commandsStr}
-
-${getFooter()}`;
-}
-
-function groupCommands(commands: CommandList, groups: GroupsType): HelpProps {
-  const help: HelpProps = commands
-    .filter((command) => !command.private && (command.shortDescription || command.description))
-    .reduce(function (partialHelp, command) {
-      const groupName = command.group as string; // at this stage, it must be set
-      partialHelp[groupName] = partialHelp[groupName] || {
-        commands: {},
-        description: groups[groupName] || capitalize(command.group),
-      };
-      const cmdId = getCommandId(command.name);
-      partialHelp[groupName].commands[cmdId] = command.shortDescription || command.description;
-      return partialHelp;
-    }, {});
-  return help;
-}
-
-function formatCommandsHelp(helpProps: HelpProps): string {
-  return Object.keys(helpProps)
-    .map((groupName) => commandsSectionTemplate(helpProps[groupName]))
-    .join('\n\n');
-}
-
-function commandsSectionTemplate(section: GroupContent): string {
-  const titleSpace = SPACE.repeat(TITLE_LEFT_SPACES_NUMBER);
-  const title = `${titleSpace}${chalk.underline.bold.blue(section.description)}`;
-  const commands = Object.keys(section.commands)
-    .map((cmdName) => commandTemplate(cmdName, section.commands[cmdName]))
-    .join('\n');
-  const res = `${title}\n${commands}`;
-  return res;
-}
-
-function commandTemplate(name: string, description: string): string {
-  const nameSpace = SPACE.repeat(COMMAND_LEFT_SPACES_NUMBER);
-  const nameWithRightSpace = rightpad(name, NAME_WITH_SPACES_LENGTH, SPACE);
-  const res = `${nameSpace}${chalk.green(nameWithRightSpace)}${description}`;
-  return res;
-}
-
-function getHeader(): string {
-  return `${chalk.bold('usage: bit [--version] [--help] <command> [<args>]')}
-
-${chalk.yellow('bit documentation: https://harmony-docs.bit.dev')}`;
-}
-
-function getFooter(): string {
-  return `${chalk.yellow("please use 'bit <command> --help' for more information and guides on specific commands.")}`;
-}

package/index.ts

@@ -1,5 +0,0 @@
-export type { CLIMain, CommandList } from './cli.main.runtime';
-export { Command, CLIArgs, Flags, GenericObject } from '@teambit/legacy/dist/cli/command';
-export { CommandOptions } from '@teambit/legacy/dist/cli/legacy-command';
-export * from './exceptions';
-export { CLIAspect, MainRuntime } from './cli.aspect';

package/legacy-command-adapter.ts

@@ -1,67 +0,0 @@
-import { LegacyCommand } from '@teambit/legacy/dist/cli/legacy-command';
-import { Command, CommandOptions, GenericObject } from '.';
-import { CLIMain } from './cli.main.runtime';
-
-export class LegacyCommandAdapter implements Command {
-  alias: string;
-  name: string;
-  description: string;
-  options: CommandOptions;
-  shortDescription?: string;
-  group?: string;
-  loader?: boolean;
-  commands: Command[];
-  private?: boolean;
-  migration?: boolean;
-  internal?: boolean;
-  skipWorkspace?: boolean;
-  _packageManagerArgs?: string[];
-  constructor(private cmd: LegacyCommand, cliExtension: CLIMain) {
-    this.name = cmd.name;
-    this.description = cmd.description;
-    this.options = cmd.opts || [];
-    this.alias = cmd.alias;
-    this.shortDescription = cmd.shortDescription;
-    this.skipWorkspace = cmd.skipWorkspace;
-    this.group = cmd.group;
-    this.loader = cmd.loader;
-    this.private = cmd.private;
-
-    this.migration = cmd.migration;
-    this.internal = cmd.internal;
-    this.commands = (cmd.commands || []).map((sub) => new LegacyCommandAdapter(sub, cliExtension));
-  }
-
-  private async action(params: any, options: { [key: string]: any }): Promise<ActionResult> {
-    const res = await this.cmd.action(params, options, this._packageManagerArgs);
-    let data = res;
-    let code = 0;
-    if (res && res.__code !== undefined) {
-      data = res.data;
-      code = res.__code;
-    }
-    const report = this.cmd.report(data, params, options);
-    return {
-      code,
-      report,
-    };
-  }
-
-  async report(params: any, options: { [key: string]: any }): Promise<{ data: string; code: number }> {
-    const actionResult = await this.action(params, options);
-    return { data: actionResult.report, code: actionResult.code };
-  }
-
-  async json(params: any, options: { [key: string]: any }): Promise<GenericObject> {
-    const actionResult = await this.action(params, options);
-    return {
-      data: JSON.parse(actionResult.report),
-      code: actionResult.code,
-    };
-  }
-}
-
-type ActionResult = {
-  code: number;
-  report: string;
-};

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-declare module '*.png' {
-  const value: any;
-  export = value;
-}
-declare module '*.svg' {
-  import type { FunctionComponent, SVGProps } from 'react';
-
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
-  const src: string;
-  export default src;
-}
-
-// @TODO Gilad
-declare module '*.jpg' {
-  const value: any;
-  export = value;
-}
-declare module '*.jpeg' {
-  const value: any;
-  export = value;
-}
-declare module '*.gif' {
-  const value: any;
-  export = value;
-}
-declare module '*.bmp' {
-  const value: any;
-  export = value;
-}

package/types/style.d.ts

@@ -1,42 +0,0 @@
-declare module '*.module.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.module.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.mdx' {
-  const component: any;
-  export default component;
-}

package/yargs-adapter.ts

@@ -1,95 +0,0 @@
-import chalk from 'chalk';
-import { Command } from '@teambit/legacy/dist/cli/command';
-import { Arguments, CommandBuilder, CommandModule } from 'yargs';
-import { TOKEN_FLAG } from '@teambit/legacy/dist/constants';
-import { camelCase } from 'lodash';
-import { CommandRunner } from './command-runner';
-
-export const GLOBAL_GROUP = 'Global';
-export const STANDARD_GROUP = 'Options';
-
-export class YargsAdapter implements CommandModule {
-  command: string;
-  describe?: string;
-  aliases?: string;
-  builder: CommandBuilder;
-  constructor(private commanderCommand: Command) {
-    this.command = commanderCommand.name;
-    this.describe = chalk.yellow(commanderCommand.description as string);
-    this.aliases = commanderCommand.alias;
-    this.builder = this.optionsToBuilder(commanderCommand);
-  }
-
-  handler(argv: Arguments) {
-    const enteredArgs = getArgsFromCommandName(this.commanderCommand.name);
-    const argsValues = enteredArgs.map((a) => argv[a]) as any[];
-    // a workaround to get a flag syntax such as "--all [version]" work with yargs.
-    const flags = Object.keys(argv).reduce((acc, current) => {
-      if (current === '_' || current === '$0' || current === '--') return acc;
-      // const flagName = current.split(' ')[0];
-      const val = typeof argv[current] === 'string' && !argv[current] ? true : argv[current];
-      acc[current] = val;
-      return acc;
-    }, {});
-    this.commanderCommand._packageManagerArgs = (argv['--'] || []) as string[];
-
-    const commandRunner = new CommandRunner(this.commanderCommand, argsValues, flags);
-    return commandRunner.runCommand();
-  }
-
-  private optionsToBuilder(command: Command) {
-    const option = command.options.reduce((acc, [alias, opt, desc]) => {
-      const optName = opt.split(' ')[0];
-      acc[optName] = {
-        alias,
-        describe: desc,
-        group: STANDARD_GROUP,
-        type: opt.includes(' ') ? 'string' : 'boolean',
-        requiresArg: opt.includes('<'),
-      };
-      return acc;
-    }, {});
-    const globalOptions = this.getGlobalOptions(command);
-
-    return { ...option, ...globalOptions };
-  }
-
-  private getGlobalOptions(command: Command): Record<string, any> {
-    const globalOptions: Record<string, any> = {};
-    if (command.remoteOp) {
-      globalOptions[TOKEN_FLAG] = {
-        describe: 'authentication token',
-        group: GLOBAL_GROUP,
-      };
-    }
-    if (!command.internal) {
-      globalOptions.log = {
-        describe:
-          'print log messages to the screen, options are: [trace, debug, info, warn, error, fatal], the default is info',
-        group: GLOBAL_GROUP,
-      };
-      globalOptions['safe-mode'] = {
-        describe:
-          'bootstrap the bare-minimum with only the CLI aspect. useful mainly for low-level commands when bit refuses to load',
-        group: GLOBAL_GROUP,
-      };
-    }
-    return globalOptions;
-  }
-}
-
-function getArgsFromCommandName(commandName: string) {
-  const commandSplit = commandName.split(' ');
-  commandSplit.shift(); // remove the first element, it's the command-name
-
-  return commandSplit.map((existArg) => {
-    const trimmed = existArg.trim();
-    if ((!trimmed.startsWith('<') && !trimmed.startsWith('[')) || (!trimmed.endsWith('>') && !trimmed.endsWith(']'))) {
-      throw new Error(`expect arg "${trimmed}" of "${commandName}" to be wrapped with "[]" or "<>"`);
-    }
-    // remove the opening and closing brackets
-    const withoutBrackets = trimmed.slice(1, -1);
-
-    return camelCase(withoutBrackets);
-  });
-}