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

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.
 
@@ -472,7 +472,7 @@ import type { WebHttpServer } from '../src/types.ts';
 /**
  * Run a web server
  */
-@CliCommand({ runTarget: true, with: { debugIpc: true, canRestart: true, module: true, env: true } })
+@CliCommand({ runTarget: true, with: { debugIpc: true, restartForDev: true, module: true, env: true } })
 export class WebHttpCommand implements CliCommandShape {
 
   /** Port to run on */
@@ -502,7 +502,7 @@ export class WebHttpCommand implements CliCommandShape {
 }
 ```
 
-As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime/src/context.ts#L12) `name` defined in the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Runtime for travetto applications.") module. 
+As noted in the example above, `fields` is specified in this execution, with support for `module`, and `env`. These env flag is directly tied to the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime/src/context.ts#L13) `name` defined in the [Runtime](https://github.com/travetto/travetto/tree/main/module/runtime#readme "Runtime for travetto applications.") module. 
 
 The `module` field is slightly more complex, but is geared towards supporting commands within a monorepo context.  This flag ensures that a module is specified if running from the root of the monorepo, and that the module provided is real, and can run the desired command.  When running from an explicit module folder in the monorepo, the module flag is ignored.
 

package/bin/trv.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 
+globalThis.__entry_point__ = __filename;
+
 // @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.3",
   "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.3",
+    "@travetto/terminal": "^7.0.0-rc.3"
   },
   "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(([regex]) => regex.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

@@ -19,8 +19,8 @@ type CliCommandConfigOptions = {
     module?: boolean;
     /** Should debug invocation trigger via ipc */
     debugIpc?: boolean;
-    /** Should the invocation automatically restart on exit */
-    canRestart?: boolean;
+    /** Should restart on code change */
+    restartForDev?: boolean;
   };
 };
 
@@ -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((executed) => executed && process.exit(0)),
       field: {
         type: Boolean,
         aliases: ['-di'],
@@ -63,13 +63,13 @@ const FIELD_CONFIG: {
       },
     },
     {
-      name: 'canRestart',
-      run: cmd => CliUtil.runWithRestart(cmd)?.then((v) => v && process.exit(0)),
+      name: 'restartForDev',
+      run: cmd => CliUtil.runWithRestartOnCodeChanges(cmd),
       field: {
         type: Boolean,
         aliases: ['-cr'],
-        description: 'Should the invocation automatically restart on exit',
-        default: false,
+        description: 'Should the invocation automatically restart on source changes',
+        default: Runtime.env === 'development',
         required: { active: false },
       },
     }
@@ -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;
@@ -27,7 +27,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     (schema.fields ??= {}).help = {
       type: Boolean,
       name: 'help',
-      owner: this.#cls,
+      class: this.#cls,
       description: 'display help for command',
       required: { active: false },
       default: false,
@@ -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;
   }