@travetto/cli 3.0.0-rc.2 → 3.0.0-rc.20

package/src/help.ts

@@ -1,6 +1,80 @@
-import * as commander from 'commander';
+import type commander from 'commander';
+
+import { cliTpl } from './color';
+
+const TYPE_PATTERN = /(\[[^\]]+\])/g;
+const REQ_TYPE_PATTERN = /(<[^>]+>)/g;
+const TITLE_PATTERN = /^(\S[^:]+:)/gim;
+
+const OPTIONS_PATTERN = new RegExp([
+  '^',
+  '(?<space>[ ]+)',
+  '(?<shortName>-[^, ]+)',
+  '(?<paramSpace>,?[ ]*)?',
+  '(?<longName>--\\S+)?',
+  '((?<typeSpace>[ ]+)?(?<type>(?:\\[[^\\]]+\\])|(?:[<][^>]+[>])))?',
+  '((?<descriptionSpace>[ ]+)(?<description>.*?))?',
+  '((?<defaultPre>[ ]*[(])(?<defaultKey>default)(?<defaultSpace>: )(?<defaultValue>[^)]+)(?<defaultPost>[)]))?',
+  '(?:[ ]+)?',
+  '$',
+].join(''), 'gim');
+
+type OptionsGroup = {
+  space: string; shortName: string;
+  paramSpace?: string; longName?: string;
+  typeSpace?: string; type?: string;
+  descriptionSpace?: string;
+  description?: string;
+  defaultPre?: string; defaultKey?: string; defaultSpace?: string; defaultValue?: string; defaultPost?: string;
+};
+
+const COMMANDS_PATTERN = new RegExp([
+  '^',
+  '(?<space>[ ]+)',
+  '(?<name>\\S+)',
+  '(?<optionsSpace>[ ]+)?',
+  '(?<options>(?:\\[|<).*(?:\\]|>))?',
+  '((?<descriptionSpace>[ ]+)(?<description>[a-z][^\\n\\[]+))?',
+  '(?:[ ]+)?',
+  '$',
+].join(''), 'gim');
+
+type CommandGroup = {
+  space: string; name: string;
+  optionsSpace?: string; options?: string;
+  descriptionSpace?: string; description?: string;
+};
+
+const USAGE_PATTERN = new RegExp([
+  '^',
+  '(?<title>Usage:)',
+  '(?<space>[ ]+)?',
+  '(?<name>[^\\[ ]+)?',
+  '(?<nameSpace>[ ]+)?',
+  '(?<options>(?:\\[|<).*(?:\\]|>))?',
+  '(?:[ ]+)?',
+  '$',
+].join(''), 'gim');
+
+type UsageGroup = {
+  title: string; space?: string;
+  name?: string; nameSpace?: string;
+  options?: string;
+};
+
+function namedReplace<T>(text: string, pattern: RegExp, replacer: (data: T) => (string | (string | undefined)[])): string {
+  return text.replace(pattern, (...args: unknown[]): string => {
+    const groups = args[args.length - 1];
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const res = replacer(groups as T);
+    if (typeof res === 'string') {
+      return res;
+    } else {
+      return res.filter(x => !!x).join('');
+    }
+  });
+}
 
-import { color } from './color';
 /**
  * Utilities for formatting help
  */
@@ -29,48 +103,60 @@ export class HelpUtil {
    * Colorize Usage
    */
   static colorizeOptions(option: string): string {
-    return option.replace(/(\s*)(-[^, ]+)(,?\s*)(--\S+)?((\s+)?((?:\[[^\]]+\])|(?:\<[^>]+>)))?((\s+)(.*))?/g, (
-      p: string, spacing: string,
-      simpleParam: string, pSep: string,
-      fullParam: string, sub: string,
-      subSp: string, subVal: string,
-      desc: string, descSp: string,
-      descVal: string
-    ) => {
-      const line: string[] = [];
-      line.push(
-        spacing,
-        color`${{ param: simpleParam }}`,
-        pSep,
-        color`${{ param: fullParam }}`,
-        subSp,
-        color`${{ type: subVal }}`,
-        descSp,
-        color`${{ description: descVal }}`
-          .replace(/(\(default:\s+)(.*?)(\))/g,
-            (__, l, input, r) => color`${l}${{ input }}${{ description: r }}`)
-      );
-
-      return line.filter(x => !!x).join('');
-    })
-      .replace(/Options:/, title => color`${{ title }}`);
+    return namedReplace<OptionsGroup>(option, OPTIONS_PATTERN,
+      ({
+        space, shortName, paramSpace, longName, typeSpace, type, descriptionSpace, description,
+        defaultPre, defaultKey, defaultSpace, defaultValue, defaultPost
+      }) =>
+        [
+          space,
+          cliTpl`${{ param: shortName }}`,
+          paramSpace,
+          cliTpl`${{ param: longName }}`,
+          typeSpace,
+          cliTpl`${{ type }}`,
+          descriptionSpace,
+          cliTpl`${{ description }}`,
+          defaultPre,
+          cliTpl`${{ description: defaultKey }}`,
+          defaultSpace,
+          cliTpl`${{ input: defaultValue }}`,
+          defaultPost
+        ]
+    )
+      .replace(TITLE_PATTERN, title => cliTpl`${{ title }}`);
   }
 
   /**
    * Colorize command section
    */
   static colorizeCommands(commands: string): string {
-    return commands
-      .replace(/\s([^\[\]]\S+)/g, param => color`${{ param }}`)
-      .replace(/(\s*[^\x1b]\[[^\]]+\])/g, input => color`${{ input }}`) // eslint-disable-line no-control-regex
-      .replace(/Commands:/, title => color`${{ title }}`);
+    return namedReplace<CommandGroup>(commands, COMMANDS_PATTERN,
+      ({ space, name, optionsSpace, options, descriptionSpace, description }) => [
+        space,
+        cliTpl`${{ param: name }}`,
+        optionsSpace,
+        options?.replace(TYPE_PATTERN, input => cliTpl`${{ input }}`).replace(REQ_TYPE_PATTERN, type => cliTpl`${{ type }}`),
+        descriptionSpace,
+        cliTpl`${{ description }}`
+      ]
+    )
+      .replace(TITLE_PATTERN, title => cliTpl`${{ title }}`);
   }
 
   /**
    * Colorize usage
    */
   static colorizeUsage(usage: string): string {
-    return usage.replace(/Usage:/, title => color`${{ title }}`);
+    return namedReplace<UsageGroup>(usage, USAGE_PATTERN,
+      ({ title, space, name, nameSpace, options }) => [
+        cliTpl`${{ title }}`,
+        space,
+        cliTpl`${{ param: name }}`,
+        nameSpace,
+        options?.replace(TYPE_PATTERN, input => cliTpl`${{ input }}`),
+      ]
+    );
   }
 
   /**
@@ -97,16 +183,15 @@ export class HelpUtil {
   /**
    * Show the help
    * @param command
-   * @param message
+   * @param failure
    * @param extra
    */
-  static showHelp(command: commander.Command, message?: string, extra?: string): never {
-    if (message) {
-      console!.error(color`${{ failure: message }}\n`);
+  static showHelp(command: commander.Command, failure?: string, extra?: string): void {
+    if (failure) {
+      console!.error(cliTpl`${{ failure }}\n`);
     }
-    console![message ? 'error' : 'log'](
+    console![failure ? 'error' : 'log'](
       HelpUtil.getHelpText(command.helpInformation(), extra)
     );
-    process.exit(message ? 1 : 0);
   }
 }

package/src/module.ts

@@ -0,0 +1,189 @@
+import { ColorDefineUtil, NAMED_COLORS, Terminal, GlobalTerminal, TermLinePosition } from '@travetto/terminal';
+import { Env, ExecutionOptions, ExecutionResult, ExecutionState, TypedObject } from '@travetto/base';
+import { IndexedModule, PackageUtil, RootIndex } from '@travetto/manifest';
+import { IterableWorkSet, WorkPool, type Worker } from '@travetto/worker';
+
+import { CliScmUtil } from './scm';
+
+type ModuleRunConfig<T = ExecutionResult> = {
+  progressMessage?: (mod: IndexedModule | undefined) => string;
+  filter?: (mod: IndexedModule) => boolean | Promise<boolean>;
+  transformResult?: (mod: IndexedModule, result: ExecutionResult) => T;
+  workerCount?: number;
+  progressPosition?: TermLinePosition;
+  prefixOutput?: boolean;
+  showStdout?: boolean;
+  showStderr?: boolean;
+};
+
+const COLORS = TypedObject.keys(NAMED_COLORS)
+  .map(k => [k, ColorDefineUtil.defineColor(k).hsl] as const)
+  .filter(([, [, s, l]]) => l > .5 && l < .8 && s > .8)
+  .map(([k]) => GlobalTerminal.colorer(k));
+
+const colorize = (val: string, idx: number): string => COLORS[idx % COLORS.length](val);
+
+/**
+ * Simple utilities for understanding modules for CLI use cases
+ */
+export class CliModuleUtil {
+
+  /**
+   * Generate execution options for running on modules
+   */
+  static #buildExecutionOptions<T = ExecutionState>(
+    mod: IndexedModule,
+    config: ModuleRunConfig<T>,
+    prefixes: Record<string, string>,
+    stdoutTerm: Terminal,
+    stderrTerm: Terminal
+  ): ExecutionOptions {
+    const folder = mod.sourceFolder;
+    const opts: ExecutionOptions = {
+      stdio: ['ignore', 'pipe', 'pipe', 'ignore'],
+      outputMode: 'text',
+      catchAsResult: true,
+      cwd: folder,
+      env: { TRV_MANIFEST: '', TRV_MODULE: mod.name },
+    };
+
+    if (config.showStdout) {
+      opts.onStdOutLine = (line: string): unknown => stdoutTerm.writeLines(`${prefixes[folder] ?? ''}${line}`);
+    }
+    if (config.showStderr) {
+      opts.onStdErrorLine = (line: string): unknown => stderrTerm.writeLines(`${prefixes[folder] ?? ''}${line}`);
+    }
+    return opts;
+  }
+
+  /**
+   * Build equal sized prefix labels for outputting
+   * @param mods
+   * @returns
+   */
+  static #buildPrefixes(mods: IndexedModule[]): Record<string, string> {
+    const folders = mods.map(x => x.sourceFolder);
+    const maxWidth = Math.max(...folders.map(x => x.length));
+    return Object.fromEntries(folders.map((x, i) => [x, colorize(x.padStart(maxWidth, ' ').padEnd(maxWidth + 1), i)]));
+  }
+
+  /**
+   * Find modules that changed, and the dependent modules
+   * @param hash
+   * @param transitive
+   * @returns
+   */
+  static async findChangedModulesRecursive(hash?: string, transitive = true): Promise<IndexedModule[]> {
+    if (!hash) {
+      hash = await CliScmUtil.findLastRelease();
+    }
+
+    if (!hash) {
+      return RootIndex.getLocalModules();
+    }
+
+    const out = new Map<string, IndexedModule>();
+    for (const mod of await CliScmUtil.findChangedModulesSince(hash)) {
+      out.set(mod.name, mod);
+      if (transitive) {
+        for (const sub of await RootIndex.getDependentModules(mod)) {
+          out.set(sub.name, sub);
+        }
+      }
+    }
+
+    return [...out.values()]
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Find modules that changed, and the dependent modules
+   * @param hash
+   * @param transitive
+   * @returns
+   */
+  static async findModules(mode: 'all' | 'changed'): Promise<IndexedModule[]> {
+    return (mode === 'changed' ?
+      await this.findChangedModulesRecursive() :
+      [...RootIndex.getModuleList('all')].map(x => RootIndex.getModule(x)!)
+    ).filter(x => x.sourcePath !== RootIndex.manifest.workspacePath);
+  }
+
+  /**
+   * Synchronize all workspace modules to have the correct versions from the current packages
+   */
+  static async synchronizeModuleVersions(): Promise<void> {
+    await PackageUtil.syncVersions((await this.findModules('all')).map(x => x.sourcePath));
+  }
+
+  /**
+   * Run on all modules
+   */
+  static async execOnModules<T = ExecutionResult>(
+    mode: 'all' | 'changed',
+    operation: (mod: IndexedModule, options: ExecutionOptions) => ExecutionState,
+    config: ModuleRunConfig<T> = {}
+  ): Promise<Map<IndexedModule, T>> {
+
+    config.showStdout = config.showStdout ?? (Env.isSet('DEBUG') && !Env.isFalse('DEBUG'));
+    config.showStderr = config.showStderr ?? true;
+
+    const workerCount = config.workerCount ?? WorkPool.DEFAULT_SIZE;
+
+    const mods = await CliModuleUtil.findModules(mode);
+    const results = new Map<IndexedModule, T>();
+    const processes = new Map<IndexedModule, ExecutionState>();
+
+    const prefixes = config.prefixOutput !== false ? this.#buildPrefixes(mods) : {};
+    const stdoutTerm = await Terminal.for({ output: process.stdout });
+    const stderrTerm = await Terminal.for({ output: process.stderr });
+
+    let id = 1;
+    const pool = new WorkPool(async () => {
+      const worker: Worker<IndexedModule> & { mod?: IndexedModule } = {
+        id: id += 1,
+        mod: undefined,
+        active: false,
+        async destroy() {
+          this.active = false;
+          processes.get(this.mod!)?.process.kill('SIGKILL');
+        },
+        async execute(mod: IndexedModule) {
+          try {
+            this.mod = mod;
+            this.active = true;
+
+            if (await config.filter?.(mod) === false) {
+              this.active = false;
+            } else {
+              const opts = CliModuleUtil.#buildExecutionOptions(mod, config, prefixes, stdoutTerm, stderrTerm);
+
+              const result = await operation(mod, opts).result;
+
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              const output = (config.transformResult ? config.transformResult(mod, result) : result) as T;
+              results.set(mod, output);
+            }
+          } finally {
+            this.active = false;
+            delete this.mod;
+          }
+        },
+      };
+      return worker;
+    }, { max: workerCount, min: workerCount });
+
+    const work = pool.iterateProcess(new IterableWorkSet(mods));
+
+    if (config.progressMessage) {
+      const cfg = { position: config.progressPosition ?? 'bottom' } as const;
+      await stdoutTerm.trackProgress(work, ev => ({ ...ev, text: config.progressMessage!(ev.value) }), cfg);
+    } else {
+      for await (const _ of work) {
+        // Ensure its all consumed
+      }
+    }
+
+    return results;
+  }
+}

package/src/scm.ts

@@ -0,0 +1,76 @@
+import fs from 'fs/promises';
+
+import { Env, ExecUtil } from '@travetto/base';
+import { IndexedModule, RootIndex, path } from '@travetto/manifest';
+
+export class CliScmUtil {
+  /**
+   * See if folder is a repository root
+   * @param folder
+   * @returns
+   */
+  static isRepoRoot(folder: string): Promise<boolean> {
+    return fs.stat(path.resolve(folder, '.git')).then(() => true, () => false);
+  }
+
+  /**
+   * Get author information
+   * @returns
+   */
+  static async getAuthor(): Promise<{ name?: string, email: string }> {
+    const [name, email] = await Promise.all([
+      await ExecUtil.spawn('git', ['config', 'user.name'], { catchAsResult: true }).result,
+      await ExecUtil.spawn('git', ['config', 'user.email']).result,
+    ]);
+    return {
+      name: (name.valid ? name.stdout.trim() : '') || Env.get('USER'),
+      email: email.stdout.trim()
+    };
+  }
+
+  /**
+   * Find the last code release
+   * @returns
+   */
+  static async findLastRelease(): Promise<string | undefined> {
+    const root = await RootIndex.manifest;
+    const { result } = ExecUtil.spawn('git', ['log', '--pretty=oneline'], { cwd: root.workspacePath });
+    return (await result).stdout
+      .split(/\n/)
+      .find(x => /Publish /.test(x))?.split(/\s+/)?.[0];
+  }
+
+  /**
+   * Find all modules that changed since hash
+   * @param hash
+   * @returns
+   */
+  static async findChangedModulesSince(hash: string): Promise<IndexedModule[]> {
+    const ws = RootIndex.manifest.workspacePath;
+    const res = await ExecUtil.spawn('git', ['diff', '--name-only', `HEAD..${hash}`], { cwd: ws }).result;
+    const out = new Set<IndexedModule>();
+    for (const line of res.stdout.split(/\n/g)) {
+      const mod = RootIndex.getFromSource(path.resolve(ws, line));
+      if (mod) {
+        out.add(RootIndex.getModule(mod.module)!);
+      }
+    }
+    return [...out].sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Create a commit
+   */
+  static createCommit(message: string): Promise<string> {
+    return ExecUtil.spawn('git', ['commit', '.', '-m', message]).result.then(r => r.stdout);
+  }
+
+  /**
+   * Verify if workspace is dirty
+   */
+  static async isWorkspaceDirty(): Promise<boolean> {
+    const res1 = await ExecUtil.spawn('git', ['diff', '--quiet', '--exit-code'], { catchAsResult: true }).result;
+    const res2 = await ExecUtil.spawn('git', ['diff', '--quiet', '--exit-code', '--cached'], { catchAsResult: true }).result;
+    return !res1.valid || !res2.valid;
+  }
+}

package/support/cli.exec.ts

@@ -0,0 +1,57 @@
+import { CliCommand, CliModuleUtil, OptionConfig } from '@travetto/cli';
+import { WorkPool } from '@travetto/worker';
+import { RootIndex } from '@travetto/manifest';
+import { ExecUtil, GlobalEnvConfig } from '@travetto/base';
+
+type Options = {
+  changed: OptionConfig<boolean>;
+  workers: OptionConfig<number>;
+  prefixOutput: OptionConfig<boolean>;
+  showStdout: OptionConfig<boolean>;
+};
+
+/**
+ * Repo execution
+ */
+export class RepoExecCommand extends CliCommand<Options> {
+  name = 'exec';
+
+  isActive(): boolean {
+    return !!RootIndex.manifest.monoRepo;
+  }
+
+  getOptions(): Options {
+    return {
+      changed: this.boolOption({ desc: 'Only changed modules', def: true }),
+      workers: this.option({ desc: 'Number of concurrent workers', def: WorkPool.DEFAULT_SIZE }),
+      prefixOutput: this.boolOption({ desc: 'Prefix output by folder', def: true }),
+      showStdout: this.boolOption({ desc: 'Show stdout', def: true })
+    };
+  }
+
+  getArgs(): string {
+    return '<command> [...args]';
+  }
+
+  envInit(): GlobalEnvConfig {
+    return { debug: false };
+  }
+
+  async action(cmd: string, args: string[]): Promise<void> {
+    if (!cmd) {
+      return this.showHelp('Command is a required field');
+    }
+
+    await CliModuleUtil.execOnModules(
+      this.cmd.changed ? 'changed' : 'all',
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      (mod, opts) => ExecUtil.spawn(cmd, args, opts),
+      {
+        progressMessage: mod => `Running '${this.args.join(' ')}' [%idx/%total] ${mod?.sourceFolder ?? ''}`,
+        showStdout: this.cmd.showStdout,
+        prefixOutput: this.cmd.prefixOutput,
+        workerCount: this.cmd.workers,
+      }
+    );
+  }
+}

package/support/cli.list.ts

@@ -0,0 +1,47 @@
+import { CliCommand, CliModuleUtil, OptionConfig } from '@travetto/cli';
+import { RootIndex } from '@travetto/manifest';
+
+type Options = {
+  changed: OptionConfig<boolean>;
+  graph: OptionConfig<boolean>;
+};
+
+/**
+ * `npx trv list`
+ *
+ * Allows for listing of modules
+ */
+export class RepoListCommand extends CliCommand<Options> {
+
+  name = 'list';
+
+  isActive(): boolean {
+    return !!RootIndex.manifest.monoRepo;
+  }
+
+  getOptions(): Options {
+    return {
+      changed: this.boolOption({ desc: 'Only show changed modules', def: false }),
+      graph: this.boolOption({ desc: 'Show as a digraph', def: false })
+    };
+  }
+
+  async action(...args: unknown[]): Promise<void> {
+    const mods = await CliModuleUtil.findModules(this.cmd.changed ? 'changed' : 'all');
+    if (!this.cmd.graph) {
+      for (const mod of mods.map(x => x.sourceFolder).sort()) {
+        console.log!(mod);
+      }
+    } else {
+      console.log!('digraph g {');
+      for (const el of mods) {
+        for (const dep of el.parents) {
+          if (dep !== RootIndex.mainPackage.name) {
+            console.log!(`  "${dep}" -> "${el.name}";`);
+          }
+        }
+      }
+      console.log!('}');
+    }
+  }
+}

package/support/cli.ts

@@ -0,0 +1,3 @@
+import { ExecutionManager } from '@travetto/cli';
+
+ExecutionManager.run(process.argv);

package/support/cli.version-sync.ts

@@ -0,0 +1,17 @@
+import { CliCommand, CliModuleUtil } from '@travetto/cli';
+import { RootIndex } from '@travetto/manifest';
+
+/**
+ * Enforces all packages to write out their versions and dependencies
+ */
+export class VersionSyncCommand extends CliCommand {
+  name = 'version-sync';
+
+  isActive(): boolean {
+    return !!RootIndex.manifest.monoRepo;
+  }
+
+  async action(): Promise<void> {
+    await CliModuleUtil.synchronizeModuleVersions();
+  }
+}

package/bin/bash-complete.sh

@@ -1,18 +0,0 @@
-# Bash Autocompletion
-_travetto()
-{
-    local trv="${PWD}/node_modules/.bin/trv";
-    local cur=${COMP_WORDS[COMP_CWORD]}    
-    if [ -f "$trv" ]; then
-      local words=`${trv} complete ${COMP_WORDS[@]:1}`
-      if [[ -z "$words" ]]; then
-        COMPREPLY=( )
-      else
-      COMPREPLY=( $(compgen  -W "$words" -- $cur) )
-      fi
-    else
-      COMPREPLY=( )
-    fi 
-}
-complete -o default -F _travetto travetto
-complete -o default -F _travetto trv

package/bin/cli.ts

@@ -1,28 +0,0 @@
-import { PathUtil } from '@travetto/boot/src/path';
-import { ModuleManager } from '@travetto/boot/src/internal/module';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-import { EnvUtil } from '@travetto/boot';
-
-/**
- * Entry point
- */
-export async function main(): Promise<void> {
-  if (!EnvUtil.isFalse('TRV_CLI_LOCAL') && !PathUtil.toUnix(__filename).includes(PathUtil.cwd)) { // If the current file is not under the working directory
-    console.error(`
-The @travetto/cli is not intended to be installed globally.  Please install it within your local project
-
-  npm i --save-dev @travetto/cli
-
-and invoke it locally using
-
-  npx trv
-`);
-    process.exit(1);
-  }
-
-  // Compile CLI for usage
-  ModuleManager.transpileAll(SourceIndex.find({ folder: 'bin' }));
-
-  const { ExecutionManager } = await import('@travetto/cli/src/execute');
-  return ExecutionManager.run(process.argv); // Run cli
-}

package/bin/trv.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-require('@travetto/boot/bin/register');
-require('@travetto/cli/bin/cli').main();

package/src/types.ts

@@ -1,17 +0,0 @@
-/**
- * Completion interface
- */
-export interface CompletionConfig {
-  /**
-   * All top level commands
-   */
-  all: string[];
-  /**
-   * Flags for sub tasks
-   */
-  task: {
-    [key: string]: {
-      [key: string]: string[];
-    };
-  };
-}