@travetto/cli 7.0.0-rc.1 → 7.0.0-rc.2

package/README.md

@@ -133,9 +133,9 @@ HELLO
 
 The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L85) supports the following data types for flags:
    *  Boolean values
-   *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L164), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L171), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L157), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) decorators help provide additional validation.
-   *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L82) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L56) provide additional constraints
-   *  Date values. The [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L91) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L102) decorators help provide additional validation.
+   *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L166), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L173), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L159), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L93) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L104) decorators help provide additional validation.
+   *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L93), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L104), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L84) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L58) provide additional constraints
+   *  Date values. The [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L93) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/input.ts#L104) decorators help provide additional validation.
    *  String lists. Same as String, but allowing multiple values.
    *  Numeric lists. Same as Number, but allowing multiple values.
 

package/bin/trv.js

@@ -2,4 +2,4 @@
 
 // @ts-check
 require('@travetto/compiler/bin/entry.common.js')
-  .load(ops => ops.exec('@travetto/cli/support/entry.trv.js'));
+  .load(operations => operations.exec('@travetto/cli/support/entry.trv.js'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
     "cli",
@@ -28,8 +28,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^7.0.0-rc.1",
-    "@travetto/terminal": "^7.0.0-rc.1"
+    "@travetto/schema": "^7.0.0-rc.2",
+    "@travetto/terminal": "^7.0.0-rc.2"
   },
   "travetto": {
     "displayName": "Command Line Interface",

package/src/error.ts

@@ -21,9 +21,9 @@ const COMMAND_PACKAGE = [
 export class CliUnknownCommandError extends Error {
 
   #getMissingCommandHelp(cmd: string): string | undefined {
-    const matchedCfg = COMMAND_PACKAGE.find(([re]) => re.test(cmd));
-    if (matchedCfg) {
-      const [, pkg, prod] = matchedCfg;
+    const matchedConfig = COMMAND_PACKAGE.find(([re]) => re.test(cmd));
+    if (matchedConfig) {
+      const [, pkg, prod] = matchedConfig;
       const install = PackageUtil.getInstallCommand(Runtime, `@travetto/${pkg}`, prod);
       return cliTpl`
 ${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n

package/src/execute.ts

@@ -13,20 +13,20 @@ import { CliCommandShape } from './types.ts';
 export class ExecutionManager {
 
   /** Error handler */
-  static async #onError(err: unknown): Promise<void> {
+  static async #onError(error: unknown): Promise<void> {
     process.exitCode ??= 1;
-    if (err instanceof CliValidationResultError) {
-      console.error!(await HelpUtil.renderValidationError(err));
-      console.error!(await HelpUtil.renderCommandHelp(err.command));
-    } else if (err instanceof CliUnknownCommandError) {
-      if (err.help) {
-        console.error!(err.help);
+    if (error instanceof CliValidationResultError) {
+      console.error!(await HelpUtil.renderValidationError(error));
+      console.error!(await HelpUtil.renderCommandHelp(error.command));
+    } else if (error instanceof CliUnknownCommandError) {
+      if (error.help) {
+        console.error!(error.help);
       } else {
-        console.error!(err.defaultMessage, '\n');
+        console.error!(error.defaultMessage, '\n');
         console.error!(await HelpUtil.renderAllHelp(''));
       }
     } else {
-      console.error!(err);
+      console.error!(error);
     }
     console.error!();
   }
@@ -72,8 +72,8 @@ export class ExecutionManager {
       } else {
         await this.#runCommand(cmd, args);
       }
-    } catch (err) {
-      await this.#onError(err);
+    } catch (error) {
+      await this.#onError(error);
     } finally {
       await ShutdownManager.gracefulShutdown('@travetto/cli:execute');
     }

package/src/help.ts

@@ -14,8 +14,8 @@ const validationSourceMap: Record<string, string> = {
   flag: 'Flag'
 };
 
-const ifDefined = <T>(v: T | null | '' | undefined): T | undefined =>
-  (v === null || v === '' || v === undefined) ? undefined : v;
+const ifDefined = <T>(value: T | null | '' | undefined): T | undefined =>
+  (value === null || value === '' || value === undefined) ? undefined : value;
 
 /**
  * Utilities for showing help
@@ -47,11 +47,11 @@ export class HelpUtil {
 
     for (const field of Object.values(schema.fields)) {
       const key = castKey<CliCommandShape>(field.name);
-      const def = ifDefined(command[key]) ?? ifDefined(field.default);
+      const defaultValue = ifDefined(command[key]) ?? ifDefined(field.default);
       const aliases = (field.aliases ?? [])
-        .filter(x => x.startsWith('-'))
-        .filter(x =>
-          (field.type !== Boolean) || ((def !== true || field.name === 'help') ? !x.startsWith('--no-') : x.startsWith('--'))
+        .filter(flag => flag.startsWith('-'))
+        .filter(flag =>
+          (field.type !== Boolean) || ((defaultValue !== true || field.name === 'help') ? !flag.startsWith('--no-') : flag.startsWith('--'))
         );
       let type: string | undefined;
 
@@ -69,14 +69,14 @@ export class HelpUtil {
       params.push(param.join(' '));
       const desc = [cliTpl`${{ title: field.description }}`];
 
-      if (key !== 'help' && def !== undefined) {
-        desc.push(cliTpl`(default: ${{ input: JSON.stringify(def) }})`);
+      if (key !== 'help' && defaultValue !== undefined) {
+        desc.push(cliTpl`(default: ${{ input: JSON.stringify(defaultValue) }})`);
       }
       descriptions.push(desc.join(' '));
     }
 
-    const paramWidths = params.map(x => util.stripVTControlCharacters(x).length);
-    const descWidths = descriptions.map(x => util.stripVTControlCharacters(x).length);
+    const paramWidths = params.map(item => util.stripVTControlCharacters(item).length);
+    const descWidths = descriptions.map(item => util.stripVTControlCharacters(item).length);
 
     const paramWidth = Math.max(...paramWidths);
     const descWidth = Math.max(...descWidths);
@@ -95,7 +95,7 @@ export class HelpUtil {
       ),
       '',
       ...helpText
-    ].map(x => x.trimEnd()).join('\n');
+    ].map(line => line.trimEnd()).join('\n');
   }
 
   /**
@@ -113,11 +113,11 @@ export class HelpUtil {
         if (schema && !schema.private) {
           rows.push(cliTpl`  ${{ param: cmd.padEnd(maxWidth, ' ') }} ${{ title: schema.description || '' }}`);
         }
-      } catch (err) {
-        if (err instanceof Error) {
-          rows.push(cliTpl`  ${{ param: cmd.padEnd(maxWidth, ' ') }} ${{ failure: err.message.split(/\n/)[0] }}`);
+      } catch (error) {
+        if (error instanceof Error) {
+          rows.push(cliTpl`  ${{ param: cmd.padEnd(maxWidth, ' ') }} ${{ failure: error.message.split(/\n/)[0] }}`);
         } else {
-          throw err;
+          throw error;
         }
       }
     }
@@ -126,20 +126,20 @@ export class HelpUtil {
 
     lines.unshift(title ? cliTpl`${{ title }}` : cliTpl`${{ title: 'Usage:' }}  ${{ param: '[options]' }} ${{ param: '[command]' }}`, '');
 
-    return lines.map(x => x.trimEnd()).join('\n');
+    return lines.map(line => line.trimEnd()).join('\n');
   }
 
   /**
    * Render validation error to a string
    */
-  static renderValidationError(err: CliValidationResultError): string {
+  static renderValidationError(validationError: CliValidationResultError): string {
     return [
       cliTpl`${{ failure: 'Execution failed' }}:`,
-      ...err.details.errors.map(e => {
-        if (e.source && e.source in validationSourceMap) {
-          return cliTpl` * ${{ identifier: validationSourceMap[e.source] }} ${{ subtitle: e.message }}`;
+      ...validationError.details.errors.map(error => {
+        if (error.source && error.source in validationSourceMap) {
+          return cliTpl` * ${{ identifier: validationSourceMap[error.source] }} ${{ subtitle: error.message }}`;
         }
-        return cliTpl` * ${{ failure: e.message }}`;
+        return cliTpl` * ${{ failure: error.message }}`;
       }),
       '',
     ].join('\n');

package/src/module.ts

@@ -47,41 +47,41 @@ export class CliModuleUtil {
   static async findModules(mode: 'all' | 'changed' | 'workspace', fromHash?: string, toHash?: string): Promise<IndexedModule[]> {
     return (mode === 'changed' ?
       await this.findChangedModulesRecursive(fromHash, toHash, true) :
-      [...RuntimeIndex.getModuleList(mode)].map(x => RuntimeIndex.getModule(x)!)
-    ).filter(x => x.sourcePath !== Runtime.workspace.path);
+      [...RuntimeIndex.getModuleList(mode)].map(name => RuntimeIndex.getModule(name)!)
+    ).filter(mod => mod.sourcePath !== Runtime.workspace.path);
   }
 
   /**
    * Get module dependency graph, fully collapsed
    */
-  static getDependencyGraph(mods: IndexedModule[]): Record<string, string[]> {
+  static getDependencyGraph(modules: IndexedModule[]): Record<string, string[]> {
     const childMap: Map<string, ModuleGraphEntry> = new Map();
     const get = (name: string): ModuleGraphEntry =>
       childMap.has(name) ? childMap.get(name)! : childMap.set(name, { children: new Set(), name, active: new Set() }).get(name)!;
 
-    for (const el of mods) {
-      get(el.name).parents = el.parents;
-      for (const dep of el.parents) {
-        const par = get(dep);
-        par.children.add(el.name); // Store child into parent
-        par.active.add(el.name);
+    for (const mod of modules) {
+      get(mod.name).parents = mod.parents;
+      for (const parentModule of mod.parents) {
+        const parent = get(parentModule);
+        parent.children.add(mod.name); // Store child into parent
+        parent.active.add(mod.name);
       }
     }
 
     const output: Record<string, string[]> = {};
 
     while (childMap.size > 0) {
-      for (const el of [...childMap.values()].filter(x => x.active.size === 0)) {
-        output[el.name] = [...el.children];
-        for (const parent of el.parents ?? []) {
+      for (const item of [...childMap.values()].filter(entry => entry.active.size === 0)) {
+        output[item.name] = [...item.children];
+        for (const parent of item.parents ?? []) {
           const par = childMap.get(parent)!;
           // Extend children into parents
-          for (const val of el.children) {
-            par.children.add(val);
+          for (const child of item.children) {
+            par.children.add(child);
           }
-          par.active.delete(el.name);
+          par.active.delete(item.name);
         }
-        childMap.delete(el.name);
+        childMap.delete(item.name);
       }
     }
     return output;
@@ -106,16 +106,16 @@ export class CliModuleUtil {
     if (config.since) {
       try {
         const files = await CliScmUtil.findChangedFiles(config.since, 'HEAD');
-        return files.filter(x => !x.endsWith('package.json') && !x.endsWith('package-lock.json'));
-      } catch (err) {
-        if (config.logError && err instanceof Error) {
-          console.error(err.message);
+        return files.filter(file => !file.endsWith('package.json') && !file.endsWith('package-lock.json'));
+      } catch (error) {
+        if (config.logError && error instanceof Error) {
+          console.error(error.message);
         }
         return [];
       }
     } else {
       const mods = await this.findModules(config.changed ? 'changed' : 'workspace', undefined, 'HEAD');
-      return mods.map(x => x.sourcePath);
+      return mods.map(mod => mod.sourcePath);
     }
   }
 }

package/src/parse.ts

@@ -16,7 +16,7 @@ const CONFIG_PRE = '+=';
 const SPACE = new Set([32, 7, 13, 10]);
 
 export const ENV_PREFIX = 'env.';
-export const isBoolFlag = (x?: SchemaInputConfig): boolean => x?.type === Boolean && !x.array;
+export const isBoolFlag = (value?: SchemaInputConfig): boolean => value?.type === Boolean && !value.array;
 
 export type AliasesParseResult = Record<'long' | 'short' | 'raw' | 'env', string[]>;
 
@@ -25,8 +25,8 @@ export type AliasesParseResult = Record<'long' | 'short' | 'raw' | 'env', string
  */
 export class CliParseUtil {
 
-  static toEnvField(k: string): string {
-    return k.startsWith(ENV_PREFIX) ? k : `${ENV_PREFIX}${k}`;
+  static toEnvField(key: string): string {
+    return key.startsWith(ENV_PREFIX) ? key : `${ENV_PREFIX}${key}`;
   }
 
   static readToken(text: string, start = 0): { next: number, value?: string } {
@@ -69,13 +69,13 @@ export class CliParseUtil {
    */
   static getSpecifiedModule(schema: SchemaClassConfig, args: string[]): string | undefined {
     const SEP = args.includes(RAW_SEP) ? args.indexOf(RAW_SEP) : args.length;
-    const input = Object.values(schema.fields).find(x => x.specifiers?.includes('module'));
-    const ENV_KEY = input?.aliases?.filter(x => x.startsWith(ENV_PREFIX)).map(x => x.replace(ENV_PREFIX, ''))[0] ?? '';
+    const input = Object.values(schema.fields).find(config => config.specifiers?.includes('module'));
+    const ENV_KEY = input?.aliases?.filter(alias => alias.startsWith(ENV_PREFIX)).map(alias => alias.replace(ENV_PREFIX, ''))[0] ?? '';
     const flags = new Set(input?.aliases ?? []);
-    const check = (k?: string, v?: string): string | undefined => flags.has(k!) ? v : undefined;
+    const check = (key?: string, value?: string): string | undefined => flags.has(key!) ? value : undefined;
     return args.reduce(
-      (m, x, i, arr) =>
-        (i < SEP ? check(arr[i - 1], x) ?? check(...x.split('=')) : undefined) ?? m,
+      (name, value, i, values) =>
+        (i < SEP ? check(values[i - 1], value) ?? check(...value.split('=')) : undefined) ?? name,
       process.env[ENV_KEY]
     );
   }
@@ -88,10 +88,10 @@ export class CliParseUtil {
     const overrides = { '@': mod ?? Runtime.main.name };
 
     // We have a file
-    const rel = (key.includes('/') ? key : `@#support/pack.${key}.flags`)
+    const relativePath = (key.includes('/') ? key : `@#support/pack.${key}.flags`)
       .replace(/^(@[^#]*)#(.*)$/, (_, imp, rest) => `${Runtime.modulePath(imp, overrides)}/${rest}`);
 
-    const file = path.resolve(rel);
+    const file = path.resolve(relativePath);
 
     if (!await fs.stat(file).catch(() => false)) {
       throw new Error(`Missing flag file: ${key}, unable to proceed`);
@@ -122,10 +122,10 @@ export class CliParseUtil {
     const max = out.includes(RAW_SEP) ? out.indexOf(RAW_SEP) : out.length;
     const valid = out.slice(0, max);
     const cmd = valid.length > 0 && !valid[0].startsWith('-') ? valid[0] : undefined;
-    const helpIdx = valid.findIndex(x => HELP_FLAG.test(x));
+    const helpIdx = valid.findIndex(flag => HELP_FLAG.test(flag));
     const args = out.slice(cmd ? 1 : 0);
-    const res = { cmd, args, help: helpIdx >= 0 };
-    return res;
+    const result = { cmd, args, help: helpIdx >= 0 };
+    return result;
   }
 
   /**
@@ -134,8 +134,8 @@ export class CliParseUtil {
   static async expandArgs(schema: SchemaClassConfig, args: string[]): Promise<string[]> {
     const SEP = args.includes(RAW_SEP) ? args.indexOf(RAW_SEP) : args.length;
     const mod = this.getSpecifiedModule(schema, args);
-    return (await Promise.all(args.map((x, i) =>
-      x.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(x, mod) : x))).flat();
+    return (await Promise.all(args.map((arg, i) =>
+      arg.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(arg, mod) : arg))).flat();
   }
 
   /**
@@ -143,21 +143,21 @@ export class CliParseUtil {
    */
   static async parse(schema: SchemaClassConfig, inputs: string[]): Promise<ParsedState> {
     const flagMap = new Map<string, SchemaFieldConfig>(
-      Object.values(schema.fields).flatMap(f => (f.aliases ?? []).map(name => [name, f]))
+      Object.values(schema.fields).flatMap(field => (field.aliases ?? []).map(name => [name, field]))
     );
 
     const out: ParsedInput[] = [];
 
     // Load env vars to front
     for (const field of Object.values(schema.fields)) {
-      for (const envName of (field.aliases ?? []).filter(x => x.startsWith(ENV_PREFIX))) {
+      for (const envName of (field.aliases ?? []).filter(alias => alias.startsWith(ENV_PREFIX))) {
         const simple = envName.replace(ENV_PREFIX, '');
         if (simple in process.env) {
           const value: string = process.env[simple]!;
           if (field.array) {
-            out.push(...value.split(/\s*,\s*/g).map(v => ({ type: 'flag', fieldName: field.name.toString(), input: envName, value: v }) as const));
+            out.push(...value.split(/\s*,\s*/g).map(item => ({ type: 'flag', fieldName: field.name, input: envName, value: item }) as const));
           } else {
-            out.push({ type: 'flag', fieldName: field.name.toString(), input: envName, value });
+            out.push({ type: 'flag', fieldName: field.name, input: envName, value });
           }
         }
       }
@@ -169,13 +169,13 @@ export class CliParseUtil {
       const input = inputs[i];
 
       if (input === RAW_SEP) { // Raw separator
-        out.push(...inputs.slice(i + 1).map((x, idx) => ({ type: 'unknown', input: x, index: argIdx + idx }) as const));
+        out.push(...inputs.slice(i + 1).map((arg, idx) => ({ type: 'unknown', input: arg, index: argIdx + idx }) as const));
         break;
       } else if (LONG_FLAG_WITH_EQ.test(input)) {
-        const [k, ...v] = input.split('=');
-        const field = flagMap.get(k);
+        const [key, ...values] = input.split('=');
+        const field = flagMap.get(key);
         if (field) {
-          out.push({ type: 'flag', fieldName: field.name.toString(), input: k, value: v.join('=') });
+          out.push({ type: 'flag', fieldName: field.name, input: key, value: values.join('=') });
         } else {
           out.push({ type: 'unknown', input });
         }
@@ -185,7 +185,7 @@ export class CliParseUtil {
           out.push({ type: 'unknown', input });
         } else {
           const next = inputs[i + 1];
-          const base = { type: 'flag', fieldName: field.name.toString(), input, array: field.array } as const;
+          const base = { type: 'flag', fieldName: field.name, input, array: field.array } as const;
           if ((next && (VALID_FLAG.test(next) || next === RAW_SEP)) || isBoolFlag(field)) {
             if (isBoolFlag(field)) {
               out.push({ ...base, value: !input.startsWith('--no-') });
@@ -211,8 +211,8 @@ export class CliParseUtil {
     return {
       inputs,
       all: out,
-      unknown: out.filter(x => x.type === 'unknown').map(x => x.input),
-      flags: out.filter(x => x.type === 'flag')
+      unknown: out.filter(input => input.type === 'unknown').map(input => input.input),
+      flags: out.filter(input => input.type === 'flag')
     };
   }
 
@@ -220,19 +220,19 @@ export class CliParseUtil {
    * Parse aliases into categories for registration
    */
   static parseAliases(aliases: string[]): AliasesParseResult {
-    return aliases.reduce<AliasesParseResult>((acc, curr) => {
-      if (VALID_FLAG.test(curr)) {
-        if (curr.startsWith('--')) {
-          acc.long.push(curr);
+    return aliases.reduce<AliasesParseResult>((result, alias) => {
+      if (VALID_FLAG.test(alias)) {
+        if (alias.startsWith('--')) {
+          result.long.push(alias);
         } else {
-          acc.short.push(curr);
+          result.short.push(alias);
         }
-      } else if (curr.startsWith(ENV_PREFIX)) {
-        acc.env.push(curr);
+      } else if (alias.startsWith(ENV_PREFIX)) {
+        result.env.push(alias);
       } else {
-        acc.raw.push(curr);
+        result.raw.push(alias);
       }
-      return acc;
+      return result;
     }, { long: [], short: [], raw: [], env: [] });
   }
 }

package/src/registry/decorator.ts

@@ -53,7 +53,7 @@ const FIELD_CONFIG: {
     },
     {
       name: 'debugIpc',
-      run: cmd => CliUtil.debugIfIpc(cmd).then((v) => v && process.exit(0)),
+      run: cmd => CliUtil.debugIfIpc(cmd).then((flag) => flag && process.exit(0)),
       field: {
         type: Boolean,
         aliases: ['-di'],
@@ -64,7 +64,7 @@ const FIELD_CONFIG: {
     },
     {
       name: 'canRestart',
-      run: cmd => CliUtil.runWithRestart(cmd)?.then((v) => v && process.exit(0)),
+      run: cmd => CliUtil.runWithRestart(cmd)?.then((flag) => flag && process.exit(0)),
       field: {
         type: Boolean,
         aliases: ['-cr'],
@@ -82,20 +82,19 @@ const FIELD_CONFIG: {
  * @example main
  * @kind decorator
  */
-export function CliCommand(cfg: CliCommandConfigOptions = {}) {
+export function CliCommand(config: CliCommandConfigOptions = {}) {
   return function <T extends CliCommandShape>(target: Class<T>): void {
     const adapter = SchemaRegistryIndex.getForRegister(target);
     const description = describeFunction(target) ?? {};
 
-
     if (!target.Ⲑid || description.abstract) {
       return;
     }
 
-    const VALID_FIELDS = FIELD_CONFIG.filter(f => !!cfg.with?.[f.name]);
+    const VALID_FIELDS = FIELD_CONFIG.filter(field => !!config.with?.[field.name]);
 
     CliCommandRegistryIndex.getForRegister(target).register({
-      runTarget: cfg.runTarget,
+      runTarget: config.runTarget,
       preMain: async (cmd: Cmd) => {
         for (const field of VALID_FIELDS) {
           await field.run(cmd);
@@ -109,7 +108,7 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
       adapter.registerField(name, field, { type });
     }
 
-    const runtimeModule = cfg.runtimeModule ?? (cfg.with?.module ? 'current' : undefined);
+    const runtimeModule = config.runtimeModule ?? (config.with?.module ? 'current' : undefined);
 
     if (runtimeModule) { // Validate module
       adapter.register({
@@ -139,14 +138,14 @@ export function CliCommand(cfg: CliCommandConfigOptions = {}) {
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function CliFlag(cfg: { full?: string, short?: string, fileExtensions?: string[], envVars?: string[] } = {}) {
-  return function (instance: ClassInstance, property: string | symbol): void {
+export function CliFlag(config: { full?: string, short?: string, fileExtensions?: string[], envVars?: string[] } = {}) {
+  return function (instance: ClassInstance, property: string): void {
     const aliases = [
-      ...(cfg.full ? [cfg.full.startsWith('-') ? cfg.full : `--${cfg.full}`] : []),
-      ...(cfg.short ? [cfg.short.startsWith('-') ? cfg.short : `-${cfg.short}`] : []),
-      ...(cfg.envVars ? cfg.envVars.map(CliParseUtil.toEnvField) : [])
+      ...(config.full ? [config.full.startsWith('-') ? config.full : `--${config.full}`] : []),
+      ...(config.short ? [config.short.startsWith('-') ? config.short : `-${config.short}`] : []),
+      ...(config.envVars ? config.envVars.map(CliParseUtil.toEnvField) : [])
     ];
-    const specifiers = cfg.fileExtensions?.length ? ['file', ...cfg.fileExtensions.map(x => `ext:${x.replace(/[*.]/g, '')}`)] : [];
+    const specifiers = config.fileExtensions?.length ? ['file', ...config.fileExtensions.map(ext => `ext:${ext.replace(/[*.]/g, '')}`)] : [];
 
     SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, { aliases, specifiers });
   };

package/src/registry/registry-adapter.ts

@@ -7,9 +7,9 @@ import { CliParseUtil, ENV_PREFIX } from '../parse.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
 
-const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
-const stripDashes = (x?: string): string | undefined => x?.replace(/^-+/, '');
-const toFlagName = (x: string): string => x.replace(/([a-z])([A-Z])/g, (_, l: string, r: string) => `${l}-${r.toLowerCase()}`);
+const getName = (name: string): string => (name.match(CLI_FILE_REGEX)?.groups?.name ?? name).replaceAll('_', ':');
+const stripDashes = (flag?: string): string | undefined => flag?.replace(/^-+/, '');
+const toFlagName = (field: string): string => field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
 
 export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConfig> {
   #cls: Class;
@@ -36,17 +36,17 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     };
 
     const used = new Set(Object.values(schema.fields)
-      .flatMap(f => f.aliases ?? [])
-      .filter(x => !x.startsWith(ENV_PREFIX))
+      .flatMap(field => field.aliases ?? [])
+      .filter(alias => !alias.startsWith(ENV_PREFIX))
       .map(stripDashes)
     );
 
     for (const field of Object.values(schema.fields)) {
-      const fieldName = field.name.toString();
+      const fieldName = field.name;
       const { long: longAliases, short: shortAliases, raw: rawAliases, env: envAliases } = CliParseUtil.parseAliases(field.aliases ?? []);
 
-      let short = stripDashes(shortAliases?.[0]) ?? rawAliases.find(x => x.length <= 2);
-      const long = stripDashes(longAliases?.[0]) ?? rawAliases.find(x => x.length >= 3) ?? toFlagName(fieldName);
+      let short = stripDashes(shortAliases?.[0]) ?? rawAliases.find(alias => alias.length <= 2);
+      const long = stripDashes(longAliases?.[0]) ?? rawAliases.find(alias => alias.length >= 3) ?? toFlagName(fieldName);
       const aliases: string[] = field.aliases = [...envAliases];
 
       if (short === undefined) {
@@ -74,14 +74,14 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
   /**
    * Registers a cli command
    */
-  register(...cfg: Partial<CliCommandConfig>[]): CliCommandConfig {
+  register(...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
     const meta = describeFunction(this.#cls);
     this.#config ??= {
       cls: this.#cls,
       preMain: undefined,
       name: getName(meta.import),
     };
-    Object.assign(this.#config, ...cfg);
+    Object.assign(this.#config, ...configs);
     return this.#config;
   }
 

package/src/registry/registry-index.ts

@@ -7,7 +7,7 @@ import { CliUnknownCommandError } from '../error.ts';
 import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
-const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
+const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?.name ?? field).replaceAll('_', ':');
 
 type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
 
@@ -38,12 +38,12 @@ export class CliCommandRegistryIndex implements RegistryIndex {
   get #commandMapping(): Map<string, string> {
     if (!this.#fileMapping) {
       const all = new Map<string, string>();
-      for (const e of RuntimeIndex.find({
-        module: m => !Runtime.production || m.prod,
-        folder: f => f === 'support',
-        file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
+      for (const entry of RuntimeIndex.find({
+        module: mod => !Runtime.production || mod.prod,
+        folder: folder => folder === 'support',
+        file: file => file.role === 'std' && CLI_FILE_REGEX.test(file.sourceFile)
       })) {
-        all.set(getName(e.sourceFile), e.import);
+        all.set(getName(entry.sourceFile), entry.import);
       }
       this.#fileMapping = all;
     }
@@ -70,32 +70,32 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     const found = this.#commandMapping.get(name)!;
     const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
     const filtered = values
-      .filter((v): v is Class => typeof v === 'function')
-      .reduce<Class[]>((acc, v) => {
-        const parent = getParentClass(v);
-        if (parent && !acc.includes(parent)) {
-          acc.push(parent);
+      .filter((value): value is Class => typeof value === 'function')
+      .reduce<Class[]>((classes, cls) => {
+        const parent = getParentClass(cls);
+        if (parent && !classes.includes(parent)) {
+          classes.push(parent);
         }
-        acc.push(v);
-        return acc;
+        classes.push(cls);
+        return classes;
       }, []);
 
     const uninitialized = filtered
-      .filter(v => !this.store.finalized(v));
+      .filter(cls => !this.store.finalized(cls));
 
 
     // Initialize any uninitialized commands
     if (uninitialized.length) {
       // Ensure processed
-      Registry.process(uninitialized.map(v => ({ type: 'added', curr: v })));
+      Registry.process(uninitialized.map(cls => ({ type: 'added', current: cls })));
     }
 
-    for (const v of values) {
-      const cfg = this.store.get(v);
-      if (!cfg) {
+    for (const cls of values) {
+      const config = this.store.get(cls);
+      if (!config) {
         continue;
       }
-      const result = cfg.getInstance();
+      const result = config.getInstance();
       if (result.isActive !== undefined && !result.isActive()) {
         continue;
       }
@@ -112,11 +112,11 @@ export class CliCommandRegistryIndex implements RegistryIndex {
   async load(names?: string[]): Promise<CliCommandLoadResult[]> {
     const keys = names ?? [...this.#commandMapping.keys()];
 
-    const list = await Promise.all(keys.map(async x => {
-      const instance = await this.#getInstance(x);
+    const list = await Promise.all(keys.map(async key => {
+      const instance = await this.#getInstance(key);
       const config = this.store.get(getClass(instance)).get();
       const schema = SchemaRegistryIndex.getConfig(getClass(instance));
-      return { command: x, instance, config, schema };
+      return { command: key, instance, config, schema };
     }));
 
     return list.sort((a, b) => a.command.localeCompare(b.command));

package/src/schema-export.ts

@@ -37,18 +37,18 @@ export class CliSchemaExportUtil {
   /**
     * Get the base type for a CLI command input
     */
-  static baseInputType(x: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
-    switch (x.type) {
+  static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
+    switch (config.type) {
       case Date: return { type: 'date' };
       case Boolean: return { type: 'boolean' };
       case Number: return { type: 'number' };
       case RegExp: return { type: 'regex' };
       case String: {
         switch (true) {
-          case x.specifiers?.includes('module'): return { type: 'module' };
-          case x.specifiers?.includes('file'): return {
+          case config.specifiers?.includes('module'): return { type: 'module' };
+          case config.specifiers?.includes('file'): return {
             type: 'file',
-            fileExtensions: x.specifiers?.map(s => s.split('ext:')[1]).filter(s => !!s)
+            fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
           };
         }
       }
@@ -59,30 +59,30 @@ export class CliSchemaExportUtil {
   /**
    * Process input configuration for CLI commands
    */
-  static processInput(x: SchemaInputConfig): CliCommandInput {
+  static processInput(config: SchemaInputConfig): CliCommandInput {
     return {
-      ...this.baseInputType(x),
-      ...(('name' in x && typeof x.name === 'string') ? { name: x.name } : { name: '' }),
-      description: x.description,
-      array: x.array,
-      required: x.required?.active !== false,
-      choices: x.enum?.values,
-      default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
-      flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
-      envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
+      ...this.baseInputType(config),
+      ...(('name' in config && typeof config.name === 'string') ? { name: config.name } : { name: '' }),
+      description: config.description,
+      array: config.array,
+      required: config.required?.active !== false,
+      choices: config.enum?.values,
+      default: Array.isArray(config.default) ? config.default.slice(0) : config.default,
+      flagNames: (config.aliases ?? []).slice(0).filter(value => !value.startsWith('env.')),
+      envVars: (config.aliases ?? []).slice(0).filter(value => value.startsWith('env.')).map(value => value.replace('env.', ''))
     };
   }
 
   static exportSchema(cls: Class): CliCommandSchema {
     const schema = SchemaRegistryIndex.getConfig(cls);
     const config = CliCommandRegistryIndex.get(cls);
-    const processed = Object.values(schema.fields).map(v => this.processInput(v));
+    const processed = Object.values(schema.fields).map(value => this.processInput(value));
     return {
       name: config.name,
       module: describeFunction(config.cls).module,
       description: schema.description,
-      flags: processed.filter(v => v.flagNames && v.flagNames.length > 0),
-      args: processed.filter(v => !v.flagNames || v.flagNames.length === 0),
+      flags: processed.filter(value => value.flagNames && value.flagNames.length > 0),
+      args: processed.filter(value => !value.flagNames || value.flagNames.length === 0),
       runTarget: config.runTarget ?? false,
       commandModule: describeFunction(cls).module,
     };

package/src/schema.ts

@@ -57,29 +57,29 @@ export class CliCommandSchemaUtil {
    */
   static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
     const cls = getClass(cmd);
-    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(x => x.name!);
+    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
 
     const validators = [
       (): Promise<void> => SchemaValidator.validate(cls, cmd).then(() => { }),
       (): Promise<void> => SchemaValidator.validateMethod(cls, 'main', args, paramNames),
       async (): Promise<void> => {
-        const res = await cmd.validate?.(...args);
-        if (res) {
-          throw new CliValidationResultError(cmd, Array.isArray(res) ? res : [res]);
+        const result = await cmd.validate?.(...args);
+        if (result) {
+          throw new CliValidationResultError(cmd, Array.isArray(result) ? result : [result]);
         }
       },
     ];
 
     const SOURCES = ['flag', 'arg', 'custom'] as const;
 
-    const results = validators.map((x, i) => x().catch(err => {
-      if (!(err instanceof CliValidationResultError) && !(err instanceof ValidationResultError)) {
-        throw err;
+    const results = validators.map((validator, i) => validator().catch(error => {
+      if (!(error instanceof CliValidationResultError) && !(error instanceof ValidationResultError)) {
+        throw error;
       }
-      return err.details.errors.map(v => ({ ...v, source: getSource(v.source, SOURCES[i]) }));
+      return error.details.errors.map(value => ({ ...value, source: getSource(value.source, SOURCES[i]) }));
     }));
 
-    const errors = (await Promise.all(results)).flatMap(x => (x ?? []));
+    const errors = (await Promise.all(results)).flatMap(result => (result ?? []));
     if (errors.length) {
       throw new CliValidationResultError(cmd, errors);
     }

package/src/scm.ts

@@ -38,7 +38,7 @@ export class CliScmUtil {
     const result = await ExecUtil.getResult(spawn('git', ['log', '--pretty=oneline'], { cwd: Runtime.workspace.path }));
     return result.stdout
       .split(/\n/)
-      .find(x => /Publish /.test(x))?.split(/\s+/)?.[0];
+      .find(line => /Publish /.test(line))?.split(/\s+/)?.[0];
   }
 
   /**
@@ -47,14 +47,14 @@ export class CliScmUtil {
    * @returns
    */
   static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
-    const ws = Runtime.workspace.path;
-    const result = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }), { catch: true });
+    const rootPath = Runtime.workspace.path;
+    const result = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: rootPath }), { catch: true });
     if (!result.valid) {
       throw new AppError('Unable to detect changes between', { category: 'data', details: { fromHash, toHash, output: (result.stderr || result.stdout) } });
     }
     const out = new Set<string>();
     for (const line of result.stdout.split(/\n/g)) {
-      const entry = RuntimeIndex.getEntry(path.resolve(ws, line));
+      const entry = RuntimeIndex.getEntry(path.resolve(rootPath, line));
       if (entry) {
         out.add(entry.sourceFile);
       }
@@ -71,10 +71,10 @@ export class CliScmUtil {
   static async findChangedModules(fromHash: string, toHash?: string): Promise<IndexedModule[]> {
     const files = await this.findChangedFiles(fromHash, toHash);
     const mods = files
-      .map(x => RuntimeIndex.getFromSource(x))
-      .filter(x => !!x)
-      .map(x => RuntimeIndex.getModule(x.module))
-      .filter(x => !!x);
+      .map(file => RuntimeIndex.getFromSource(file))
+      .filter(file => !!file)
+      .map(file => RuntimeIndex.getModule(file.module))
+      .filter(mod => !!mod);
 
     return [...new Set(mods)]
       .toSorted((a, b) => a.name.localeCompare(b.name));
@@ -84,7 +84,7 @@ export class CliScmUtil {
    * Create a commit
    */
   static createCommit(message: string): Promise<string> {
-    return ExecUtil.getResult(spawn('git', ['commit', '.', '-m', message])).then(r => r.stdout);
+    return ExecUtil.getResult(spawn('git', ['commit', '.', '-m', message])).then(result => result.stdout);
   }
 
   /**
@@ -92,7 +92,7 @@ export class CliScmUtil {
    */
   static createTag(version: string): Promise<string> {
     version = version.replace(/[^0-9a-z_\-.]/g, '');
-    return ExecUtil.getResult(spawn('git', ['tag', '-a', `${version}`, '-m', `Release ${version}`])).then(r => r.stdout);
+    return ExecUtil.getResult(spawn('git', ['tag', '-a', `${version}`, '-m', `Release ${version}`])).then(result => result.stdout);
   }
 
   /**

package/src/service.ts

@@ -5,11 +5,11 @@ import net from 'node:net';
 
 import { ExecUtil, TimeUtil, Util } from '@travetto/runtime';
 
-const ports = (val: number | `${number}:${number}`): [number, number] =>
-  typeof val === 'number' ?
-    [val, val] :
+const ports = (value: number | `${number}:${number}`): [number, number] =>
+  typeof value === 'number' ?
+    [value, value] :
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    val.split(':').map(x => parseInt(x, 10)) as [number, number];
+    value.split(':').map(number => parseInt(number, 10)) as [number, number];
 
 type BodyCheck = (body: string) => boolean;
 
@@ -36,26 +36,26 @@ export type ServiceAction = 'start' | 'stop' | 'status' | 'restart';
  */
 export class ServiceRunner {
 
-  svc: ServiceDescriptor;
-  constructor(svc: ServiceDescriptor) { this.svc = svc; }
+  #descriptor: ServiceDescriptor;
+  constructor(descriptor: ServiceDescriptor) { this.#descriptor = descriptor; }
 
   async #isRunning(full = false): Promise<boolean> {
-    const port = ports(this.svc.port!)[0];
+    const port = ports(this.#descriptor.port!)[0];
     const start = Date.now();
-    const timeoutMs = TimeUtil.asMillis(full ? this.svc.startupTimeout ?? 5000 : 100);
+    const timeoutMs = TimeUtil.asMillis(full ? this.#descriptor.startupTimeout ?? 5000 : 100);
     while ((Date.now() - start) < timeoutMs) {
       try {
         const sock = net.createConnection(port, 'localhost');
-        await new Promise<void>((res, rej) =>
-          sock.on('connect', res).on('timeout', rej).on('error', rej)
+        await new Promise<void>((resolve, reject) =>
+          sock.on('connect', resolve).on('timeout', reject).on('error', reject)
         ).finally(() => sock.destroy());
 
-        if (!this.svc.ready?.url || !full) {
+        if (!this.#descriptor.ready?.url || !full) {
           return true;
         } else {
-          const response = await fetch(this.svc.ready.url, { method: 'GET' });
+          const response = await fetch(this.#descriptor.ready.url, { method: 'GET' });
           const text = await response.text();
-          if (response.ok && (this.svc.ready.test?.(text) ?? true)) {
+          if (response.ok && (this.#descriptor.ready.test?.(text) ?? true)) {
             return true;
           }
         }
@@ -68,14 +68,14 @@ export class ServiceRunner {
   }
 
   async #hasImage(): Promise<boolean> {
-    const result = await ExecUtil.getResult(spawn('docker', ['image', 'inspect', this.svc.image]), { catch: true });
+    const result = await ExecUtil.getResult(spawn('docker', ['image', 'inspect', this.#descriptor.image]), { catch: true });
     return result.valid;
   }
 
   async * #pullImage(): AsyncIterable<string> {
-    const proc = spawn('docker', ['pull', this.svc.image], { stdio: [0, 'pipe', 'pipe'] });
-    yield* rl.createInterface(proc.stdout!);
-    await ExecUtil.getResult(proc);
+    const subProcess = spawn('docker', ['pull', this.#descriptor.image], { stdio: [0, 'pipe', 'pipe'] });
+    yield* rl.createInterface(subProcess.stdout!);
+    await ExecUtil.getResult(subProcess);
   }
 
   async #startContainer(): Promise<string> {
@@ -83,16 +83,16 @@ export class ServiceRunner {
       'run',
       '--rm',
       '--detach',
-      ...this.svc.privileged ? ['--privileged'] : [],
-      '--label', `trv-${this.svc.name}`,
-      ...Object.entries(this.svc.env ?? {}).flatMap(([k, v]) => ['--env', `${k}=${v}`]),
-      ...this.svc.port ? ['-p', ports(this.svc.port).join(':')] : [],
-      ...Object.entries(this.svc.volumes ?? {}).flatMap(([k, v]) => ['--volume', `${k}:${v}`]),
-      this.svc.image,
-      ...this.svc.args ?? [],
+      ...this.#descriptor.privileged ? ['--privileged'] : [],
+      '--label', `trv-${this.#descriptor.name}`,
+      ...Object.entries(this.#descriptor.env ?? {}).flatMap(([key, value]) => ['--env', `${key}=${value}`]),
+      ...this.#descriptor.port ? ['-p', ports(this.#descriptor.port).join(':')] : [],
+      ...Object.entries(this.#descriptor.volumes ?? {}).flatMap(([key, value]) => ['--volume', `${key}:${value}`]),
+      this.#descriptor.image,
+      ...this.#descriptor.args ?? [],
     ];
 
-    for (const item of Object.keys(this.svc.volumes ?? {})) {
+    for (const item of Object.keys(this.#descriptor.volumes ?? {})) {
       await fs.mkdir(item, { recursive: true });
     }
 
@@ -100,38 +100,38 @@ export class ServiceRunner {
   }
 
   async #getContainerId(): Promise<string | undefined> {
-    return (await ExecUtil.getResult(spawn('docker', ['ps', '-q', '--filter', `label=trv-${this.svc.name}`]))).stdout.trim();
+    return (await ExecUtil.getResult(spawn('docker', ['ps', '-q', '--filter', `label=trv-${this.#descriptor.name}`]))).stdout.trim();
   }
 
-  async #killContainer(cid: string): Promise<void> {
-    await ExecUtil.getResult(spawn('docker', ['kill', cid]));
+  async #killContainer(containerId: string): Promise<void> {
+    await ExecUtil.getResult(spawn('docker', ['kill', containerId]));
   }
 
-  async * action(op: ServiceAction): AsyncIterable<['success' | 'failure' | 'message', string]> {
+  async * action(operation: ServiceAction): AsyncIterable<['success' | 'failure' | 'message', string]> {
     try {
-      const cid = await this.#getContainerId();
-      const port = this.svc.port ? ports(this.svc.port)[0] : 0;
-      const running = !!cid && (!port || await this.#isRunning());
+      const containerId = await this.#getContainerId();
+      const port = this.#descriptor.port ? ports(this.#descriptor.port)[0] : 0;
+      const running = !!containerId && (!port || await this.#isRunning());
 
-      if (running && !cid) { // We don't own
-        return yield [op === 'status' ? 'message' : 'failure', 'Running but not managed'];
+      if (running && !containerId) { // We don't own
+        return yield [operation === 'status' ? 'message' : 'failure', 'Running but not managed'];
       }
 
-      if (op === 'status') {
-        return yield !cid ? ['message', 'Not running'] : ['success', `Running ${cid}`];
-      } else if (op === 'start' && running) {
+      if (operation === 'status') {
+        return yield !containerId ? ['message', 'Not running'] : ['success', `Running ${containerId}`];
+      } else if (operation === 'start' && running) {
         return yield ['message', 'Skipping, already running'];
-      } else if (op === 'stop' && !running) {
+      } else if (operation === 'stop' && !running) {
         return yield ['message', 'Skipping, already stopped'];
       }
 
-      if (running && (op === 'restart' || op === 'stop')) {
+      if (running && (operation === 'restart' || operation === 'stop')) {
         yield ['message', 'Stopping'];
-        await this.#killContainer(cid);
+        await this.#killContainer(containerId);
         yield ['success', 'Stopped'];
       }
 
-      if (op === 'restart' || op === 'start') {
+      if (operation === 'restart' || operation === 'start') {
         if (!await this.#hasImage()) {
           yield ['message', 'Starting image download'];
           for await (const line of await this.#pullImage()) {
@@ -144,7 +144,7 @@ export class ServiceRunner {
         const out = await this.#startContainer();
 
         if (port) {
-          yield ['message', `Waiting for ${this.svc.ready?.url ?? 'container'}...`];
+          yield ['message', `Waiting for ${this.#descriptor.ready?.url ?? 'container'}...`];
           if (!await this.#isRunning(true)) {
             yield ['failure', 'Failed to start service correctly'];
           }

package/src/util.ts

@@ -6,7 +6,9 @@ import { CliCommandShape, CliCommandShapeFields } from './types.ts';
 
 const IPC_ALLOWED_ENV = new Set(['NODE_OPTIONS']);
 const IPC_INVALID_ENV = new Set(['PS1', 'INIT_CWD', 'COLOR', 'LANGUAGE', 'PROFILEHOME', '_']);
-const validEnv = (k: string): boolean => IPC_ALLOWED_ENV.has(k) || (!IPC_INVALID_ENV.has(k) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(k) && !/VSCODE/.test(k));
+const validEnv = (key: string): boolean => IPC_ALLOWED_ENV.has(key) || (
+  !IPC_INVALID_ENV.has(key) && !/^(npm_|GTK|GDK|TRV|NODE|GIT|TERM_)/.test(key) && !/VSCODE/.test(key)
+);
 
 export class CliUtil {
   /**
@@ -51,14 +53,14 @@ export class CliUtil {
       return false;
     }
 
-    const info = await fetch(Env.TRV_CLI_IPC.val!).catch(() => ({ ok: false }));
+    const info = await fetch(Env.TRV_CLI_IPC.value!).catch(() => ({ ok: false }));
 
     if (!info.ok) { // Server not running
       return false;
     }
 
     const env: Record<string, string> = {};
-    const req = {
+    const request = {
       type: `@travetto/cli:${action}`,
       data: {
         name: cmd._cfg!.name,
@@ -69,10 +71,10 @@ export class CliUtil {
         args: process.argv.slice(3),
       }
     };
-    console.log('Triggering IPC request', req);
+    console.log('Triggering IPC request', request);
 
-    Object.entries(process.env).forEach(([k, v]) => validEnv(k) && (env[k] = v!));
-    const sent = await fetch(Env.TRV_CLI_IPC.val!, { method: 'POST', body: JSON.stringify(req) });
+    Object.entries(process.env).forEach(([key, value]) => validEnv(key) && (env[key] = value!));
+    const sent = await fetch(Env.TRV_CLI_IPC.value!, { method: 'POST', body: JSON.stringify(request) });
     return sent.ok;
   }
 
@@ -87,6 +89,6 @@ export class CliUtil {
    * Write data to channel and ensure its flushed before continuing
    */
   static async writeAndEnsureComplete(data: unknown, channel: 'stdout' | 'stderr' = 'stdout'): Promise<void> {
-    return await new Promise(r => process[channel].write(typeof data === 'string' ? data : JSON.stringify(data, null, 2), () => r()));
+    return await new Promise(resolve => process[channel].write(typeof data === 'string' ? data : JSON.stringify(data, null, 2), () => resolve()));
   }
 }

package/support/cli.cli_schema.ts

@@ -20,7 +20,7 @@ export class CliSchemaCommand implements CliCommandShape {
       return;
     }
     const resolved = await CliCommandRegistryIndex.load(names);
-    const invalid = names.find(x => !resolved.find(r => r.command === x));
+    const invalid = names.find(name => !resolved.find(result => result.command === name));
 
     if (invalid) {
       return {
@@ -38,7 +38,7 @@ export class CliSchemaCommand implements CliCommandShape {
     const resolved = await CliCommandRegistryIndex.load(names);
 
     const output = resolved
-      .map(x => CliSchemaExportUtil.exportSchema(x.config.cls));
+      .map(result => CliSchemaExportUtil.exportSchema(result.config.cls));
 
     await CliUtil.writeAndEnsureComplete(output);
   }

package/support/cli.main.ts

@@ -25,8 +25,8 @@ export class MainCommand implements CliCommandShape {
     try {
       const mod = await Runtime.importFrom<{ main(..._: unknown[]): Promise<unknown> }>(fileOrImport);
       result = await mod.main(...args, ...this._parsed.unknown);
-    } catch (err) {
-      result = err;
+    } catch (error) {
+      result = error;
       process.exitCode = Math.max(process.exitCode ? +process.exitCode : 1, 1);
     }
 

package/support/cli.service.ts

@@ -13,14 +13,14 @@ export class CliServiceCommand implements CliCommandShape {
   async #getServices(services: string[]): Promise<ServiceDescriptor[]> {
     return (await Promise.all(
       RuntimeIndex.find({
-        module: m => m.roles.includes('std'),
-        folder: f => f === 'support',
-        file: f => /support\/service[.]/.test(f.sourceFile)
+        module: mod => mod.roles.includes('std'),
+        folder: folder => folder === 'support',
+        file: file => /support\/service[.]/.test(file.sourceFile)
       })
-        .map(x => Runtime.importFrom<{ service: ServiceDescriptor }>(x.import).then(v => v.service))
+        .map(file => Runtime.importFrom<{ service: ServiceDescriptor }>(file.import).then(value => value.service))
     ))
-      .filter(x => !!x)
-      .filter(x => services?.length ? services.includes(x.name) : true)
+      .filter(file => !!file)
+      .filter(file => services?.length ? services.includes(file.name) : true)
       .toSorted((a, b) => a.name.localeCompare(b.name));
   }
 
@@ -37,29 +37,29 @@ export class CliServiceCommand implements CliCommandShape {
     return [
       cliTpl`${{ title: 'Available Services' }}`,
       '-'.repeat(20),
-      ...all.map(x => cliTpl` * ${{ identifier: x.name }}@${{ type: x.version }}`)
+      ...all.map(service => cliTpl` * ${{ identifier: service.name }}@${{ type: service.version }}`)
     ];
   }
 
   async main(action: ServiceAction, services: string[] = []): Promise<void> {
     const all = await this.#getServices(services);
-    const maxName = Math.max(...all.map(x => x.name.length), 'Service'.length) + 3;
-    const maxVersion = Math.max(...all.map(x => `${x.version}`.length), 'Version'.length) + 3;
+    const maxName = Math.max(...all.map(service => service.name.length), 'Service'.length) + 3;
+    const maxVersion = Math.max(...all.map(service => `${service.version}`.length), 'Version'.length) + 3;
     const maxStatus = 20;
-    const q = new AsyncQueue<{ idx: number, text: string, done?: boolean }>();
+    const queue = new AsyncQueue<{ idx: number, text: string, done?: boolean }>();
 
-    const jobs = all.map(async (v, i) => {
-      const identifier = v.name.padEnd(maxName);
-      const type = `${v.version}`.padStart(maxVersion - 3).padEnd(maxVersion);
+    const jobs = all.map(async (descriptor, i) => {
+      const identifier = descriptor.name.padEnd(maxName);
+      const type = `${descriptor.version}`.padStart(maxVersion - 3).padEnd(maxVersion);
       let msg: string;
-      for await (const [valueType, value] of new ServiceRunner(v).action(action)) {
+      for await (const [valueType, value] of new ServiceRunner(descriptor).action(action)) {
         const details = { [valueType === 'message' ? 'subtitle' : valueType]: value };
-        q.add({ idx: i, text: msg = cliTpl`${{ identifier }} ${{ type }} ${details}` });
+        queue.add({ idx: i, text: msg = cliTpl`${{ identifier }} ${{ type }} ${details}` });
       }
-      q.add({ idx: i, done: true, text: msg! });
+      queue.add({ idx: i, done: true, text: msg! });
     });
 
-    Promise.all(jobs).then(() => Util.queueMacroTask()).then(() => q.close());
+    Promise.all(jobs).then(() => Util.queueMacroTask()).then(() => queue.close());
 
     const term = new Terminal();
     await term.writer.writeLines([
@@ -68,6 +68,6 @@ export class CliServiceCommand implements CliCommandShape {
       ''.padEnd(maxName + maxVersion + maxStatus + 3, '-'),
     ]).commit();
 
-    await term.streamList(q);
+    await term.streamList(queue);
   }
 }