@teambit/cli 0.0.839 → 0.0.840

package/generate-doc-md.ts

@@ -0,0 +1,167 @@
+import { Command, CommandArg } from '@teambit/legacy/dist/cli/command';
+import { CommandOptions } from '@teambit/legacy/dist/cli/legacy-command';
+import { pick } from 'lodash';
+import { getCommandId } from './get-command-id';
+
+export type GenerateOpts = {
+  metadata?: Record<string, string>;
+};
+
+type CommandObject = ReturnType<typeof oneCommandToObject> & { commands?: any };
+
+export class GenerateCommandsDoc {
+  constructor(private commands: Command[], private options: GenerateOpts) {}
+
+  generate(): string {
+    const commands = this.getAllPublicCommandsSorted();
+    let output = `${this.getFrontmatter()}
+# CLI Reference
+
+Run the following to list all available Bit commands (alternatively, use the \`-h\` alias, instead of \`--help\`):
+
+\`\`\`sh
+bit --help
+\`\`\`
+
+Run the following to get help on a specific command:
+
+\`\`\`sh
+bit COMMAND --help
+\`\`\`
+
+Run the following to get help on a specific sub-command:
+
+\`\`\`sh
+bit COMMAND SUB_COMMAND --help
+\`\`\`
+`;
+    output += commands.map((cmd) => this.generateCommand(cmd)).join('\n');
+
+    return output;
+  }
+
+  generateJson() {
+    return this.commandsToObjects();
+  }
+
+  private commandsToObjects(commands: Command[] = this.commands): CommandObject[] {
+    return commands.map((command) => {
+      const cmdObject: CommandObject = oneCommandToObject(command);
+      if (command.commands?.length) {
+        cmdObject.commands = this.commandsToObjects(command.commands);
+      }
+      return cmdObject;
+    });
+  }
+
+  private getFrontmatter() {
+    const metadata = this.options.metadata;
+    if (!metadata) {
+      return '';
+    }
+    const metadataStr = Object.keys(metadata)
+      .map((key) => `${key}: ${metadata[key]}`)
+      .join('\n');
+
+    return `---
+    ${metadataStr}
+    ---
+`;
+  }
+
+  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 += `**Description**: ${this.formatDescription(cmd)}`;
+    result += `\`bit ${cmd.name}\`  \n\n`;
+
+    if (cmd.commands && cmd.commands.length > 0) {
+      result += this.generateSubCommands(cmd.commands, cmd);
+    }
+    result += this.generateArguments(cmd.arguments);
+    result += this.generateOptions(cmd.options);
+    result += `---  \n`;
+
+    return result;
+  }
+
+  private generateSubCommands(subCommands: Command[], command: Command) {
+    let ret = '';
+    subCommands.forEach((subCommand) => {
+      const commandName = getCommandId(command.name);
+      const subcommandName = getCommandId(subCommand.name);
+      const usage = `${commandName} ${subCommand.name}`;
+      ret += `### ${commandName} ${subcommandName} \n`;
+      ret += `**Usage**: \`${usage}\`  \n\n`;
+      ret += `**Description**: ${this.formatDescription(subCommand)}`;
+
+      ret += '\n';
+      ret += this.generateArguments(subCommand.arguments);
+      ret += this.generateOptions(subCommand.options);
+    });
+    return ret;
+  }
+
+  private generateArguments(args?: CommandArg[]): string {
+    if (!args || !args.length) return '';
+    let output = `| **Arg** | **Description** |  \n`;
+    output += `|---|:-----:|\n`;
+    args.forEach((arg) => {
+      const { name, description } = arg;
+      output += `|\`${name}\`|${(description || '').replaceAll('\n', ' ')}|\n`;
+    });
+    output += `\n`;
+    return output;
+  }
+
+  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.replaceAll('\n', ' ')}|\n`;
+    });
+    output += `\n`;
+    return output;
+  }
+
+  private formatStringToMD(str: string): string {
+    return str.split('\n').join('  \n');
+  }
+
+  private formatDescription(command: Command): string {
+    const extendedDescription = command.extendedDescription
+      ? `  \n${this.formatStringToMD(command.extendedDescription)}`
+      : '';
+    const description = this.formatStringToMD(command.description as string);
+    return `${description}${extendedDescription}  \n\n`;
+  }
+}
+
+function oneCommandToObject(command: Command) {
+  return pick(command, [
+    'name',
+    'alias',
+    'options',
+    'description',
+    'extendedDescription',
+    'group',
+    'private',
+    'internal',
+    'remoteOp',
+    'skipWorkspace',
+    'arguments',
+    'examples',
+  ]);
+}

package/get-command-id.ts

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

package/help.cmd.ts

@@ -0,0 +1,18 @@
+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 = [['', 'internal', 'show internal commands']] as CommandOptions;
+
+  constructor(private cliMain: CLIMain) {}
+
+  async report(_, { internal }: { internal: boolean }) {
+    return formatHelp(this.cliMain.commands, this.cliMain.groups, internal);
+  }
+}

package/help.ts

@@ -0,0 +1,80 @@
+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, showPrivateCommands = false) {
+  const helpProps = groupCommands(commands, groups, showPrivateCommands);
+  const commandsStr = formatCommandsHelp(helpProps);
+
+  return `${getHeader()}
+
+${commandsStr}
+
+${getFooter()}`;
+}
+
+function groupCommands(commands: CommandList, groups: GroupsType, showPrivateCommands = false): HelpProps {
+  const help: HelpProps = commands
+    .filter((command) => (showPrivateCommands ? true : !command.private && 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.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://bit.dev/`)}`;
+}
+
+function getFooter(): string {
+  return `${chalk.yellow("please use 'bit <command> --help' for more information and guides on specific commands.")}`;
+}

package/index.ts

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

package/legacy-command-adapter.ts

@@ -0,0 +1,68 @@
+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;
+  extendedDescription?: string;
+  group?: string;
+  loader?: boolean;
+  commands: Command[];
+  private?: boolean;
+  migration?: boolean;
+  internal?: boolean;
+  skipWorkspace?: boolean;
+  helpUrl?: string;
+  _packageManagerArgs?: string[];
+  constructor(private cmd: LegacyCommand, cliExtension: CLIMain) {
+    this.name = cmd.name;
+    this.description = cmd.description;
+    this.helpUrl = cmd.helpUrl;
+    this.options = cmd.opts || [];
+    this.alias = cmd.alias;
+    this.extendedDescription = cmd.extendedDescription;
+    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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/cli",
-  "version": "0.0.839",
+  "version": "0.0.840",
   "homepage": "https://bit.cloud/teambit/harmony/cli",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.harmony",
     "name": "cli",
-    "version": "0.0.839"
+    "version": "0.0.840"
   },
   "dependencies": {
     "chalk": "2.4.2",
@@ -16,27 +16,23 @@
     "p-map-series": "2.1.0",
     "ink": "3.2.0",
     "pad-right": "0.2.2",
-    "core-js": "^3.0.0",
-    "@babel/runtime": "7.20.0",
     "@teambit/harmony": "0.4.6",
     "@teambit/bit-error": "0.0.404",
-    "@teambit/logger": "0.0.932"
+    "@teambit/logger": "0.0.933"
   },
   "devDependencies": {
     "@types/didyoumean": "1.2.0",
     "@types/lodash": "4.14.165",
     "@types/yargs": "17.0.0",
-    "@types/react": "^17.0.8",
     "@types/mocha": "9.1.0",
-    "@types/node": "12.20.4",
-    "@types/react-dom": "^17.0.5",
-    "@types/jest": "^26.0.0",
-    "@types/testing-library__jest-dom": "5.9.5"
+    "@types/jest": "^29.2.2",
+    "@types/testing-library__jest-dom": "^5.9.5",
+    "@teambit/harmony.envs.core-aspect-env": "0.0.13"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.624",
-    "react": "^16.8.0 || ^17.0.0",
-    "react-dom": "^16.8.0 || ^17.0.0"
+    "react": "^17.0.0 || ^18.0.0",
+    "@types/react": "^18.2.12",
+    "@teambit/legacy": "1.0.624"
   },
   "license": "Apache-2.0",
   "optionalDependencies": {},
@@ -50,7 +46,7 @@
   },
   "private": false,
   "engines": {
-    "node": ">=12.22.0"
+    "node": ">=16.0.0"
   },
   "repository": {
     "type": "git",
@@ -59,12 +55,9 @@
   "keywords": [
     "bit",
     "bit-aspect",
+    "bit-core-aspect",
     "components",
     "collaboration",
-    "web",
-    "react",
-    "react-components",
-    "angular",
-    "angular-components"
+    "web"
   ]
 }

package/tsconfig.json

@@ -1,38 +1,33 @@
 {
   "compilerOptions": {
     "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable",
-      "ScriptHost"
+      "esnext",
+      "dom",
+      "dom.Iterable"
     ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
+    "target": "es2020",
+    "module": "es2020",
+    "jsx": "react-jsx",
     "declaration": true,
     "sourceMap": true,
-    "skipLibCheck": true,
     "experimentalDecorators": true,
-    "outDir": "dist",
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "rootDir": ".",
     "resolveJsonModule": true,
-    "emitDeclarationOnly": true,
-    "emitDecoratorMetadata": true,
-    "allowSyntheticDefaultImports": true,
-    "strictPropertyInitialization": false,
-    "strict": true,
-    "noImplicitAny": false,
-    "preserveConstEnums": true
+    "allowJs": true,
+    "outDir": "dist",
+    "emitDeclarationOnly": true
   },
   "exclude": [
+    "artifacts",
+    "public",
     "dist",
+    "node_modules",
+    "package.json",
     "esm.mjs",
-    "package.json"
+    "**/*.cjs",
+    "./dist"
   ],
   "include": [
     "**/*",

package/types/asset.d.ts

@@ -5,12 +5,12 @@ declare module '*.png' {
 declare module '*.svg' {
   import type { FunctionComponent, SVGProps } from 'react';
 
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
   const src: string;
   export default src;
 }
-
-// @TODO Gilad
 declare module '*.jpg' {
   const value: any;
   export = value;
@@ -27,3 +27,15 @@ declare module '*.bmp' {
   const value: any;
   export = value;
 }
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  const value: any;
+  export = value;
+}

package/version.cmd.ts

@@ -0,0 +1,21 @@
+import { Command, CommandOptions } from '@teambit/cli';
+import { getHarmonyVersion } from '@teambit/legacy/dist/bootstrap';
+
+export class VersionCmd implements Command {
+  name = 'version';
+  description = 'shows bit version';
+  alias = '';
+  loader = false;
+  group = 'general';
+  options = [['j', 'json', 'return the version in json format']] as CommandOptions;
+
+  async report() {
+    const results = await this.json();
+    return results.bit;
+  }
+
+  async json() {
+    const bit = getHarmonyVersion(true);
+    return { bit };
+  }
+}

package/yargs-adapter.ts

@@ -0,0 +1,109 @@
+import { Command } from '@teambit/legacy/dist/cli/command';
+import { Arguments, CommandModule, Argv, Options } 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;
+  constructor(private commanderCommand: Command) {
+    this.command = commanderCommand.name;
+    this.describe = commanderCommand.description;
+    this.aliases = commanderCommand.alias;
+  }
+
+  builder(yargs: Argv) {
+    const options = YargsAdapter.optionsToBuilder(this.commanderCommand);
+    yargs.option(options);
+    this.commanderCommand.arguments?.forEach((arg) => {
+      yargs.positional(arg.name, { description: arg.description });
+    });
+    this.commanderCommand.examples?.forEach((example) => {
+      yargs.example(example.cmd, example.description);
+    });
+
+    return yargs;
+  }
+
+  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();
+  }
+
+  get positional() {
+    return this.commanderCommand.arguments;
+  }
+
+  static optionsToBuilder(command: Command): { [key: string]: Options } {
+    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('<'),
+      } as Options;
+      return acc;
+    }, {});
+    const globalOptions = YargsAdapter.getGlobalOptions(command);
+
+    return { ...option, ...globalOptions };
+  }
+
+  static 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);
+  });
+}