@travetto/cli 6.0.0 → 7.0.0-rc.0

package/README.md

@@ -28,8 +28,8 @@ Commands:
   email:compile     CLI Entry point for running the email server
   email:editor      The email editor compilation service and output serving
   email:test        CLI Entry point for running the email server
-  lint              Command line support for linting
-  lint:register     Writes the lint configuration file
+  eslint            Command line support for eslint
+  eslint:register   Writes the eslint configuration file
   model:export      Exports model schemas
   model:install     Installing models
   openapi:client    CLI for generating the cli client
@@ -59,7 +59,7 @@ This module also has a tight integration with the [VSCode plugin](https://market
 At it's heart, a cli command is the contract defined by what flags, and what arguments the command supports. Within the framework this requires three criteria to be met:
    *  The file must be located in the `support/` folder, and have a name that matches `cli.*.ts`
    *  The file must be a class that has a main method
-   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L84) decorator
+   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L85) decorator
 
 **Code: Basic Command**
 ```typescript
@@ -94,7 +94,7 @@ Examples of mappings:
 The pattern is that underscores(_) translate to colons (:), and the `cli.` prefix, and `.ts` suffix are dropped.
 
 ## Binding Flags
-[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L84) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L84) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) class. The fields of the class represent the flags that are available to the command.
+[@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L85) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L85) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) class. The fields of the class represent the flags that are available to the command.
 
 **Code: Basic Command with Flag**
 ```typescript
@@ -131,11 +131,11 @@ $ trv basic:flag --loud
 HELLO
 ```
 
-The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L84) supports the following data types for flags:
+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/field.ts#L164), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L170), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L158), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) decorators help provide additional validation.
-   *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L91) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L70) provide additional constraints
-   *  Date values. The [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L109) decorators help provide additional validation.
+   *  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.
    *  String lists. Same as String, but allowing multiple values.
    *  Numeric lists. Same as Number, but allowing multiple values.
 
@@ -251,7 +251,7 @@ $ trv basic:arglist -r 10 5 3 9 8 1
 ```
 
 ## Customization
-By default, all fields are treated as flags and all parameters of `main()` are treated as arguments within the validation process.  Like the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) behavior, we can leverage the metadata of the fields/parameters to help provide additional customization/context for the users of the commands.
+By default, all fields are treated as flags and all parameters of `main()` are treated as arguments within the validation process.  Like the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) behavior, we can leverage the metadata of the fields/parameters to help provide additional customization/context for the users of the commands.
 
 **Code: Custom Command with Metadata**
 ```typescript
@@ -390,7 +390,7 @@ npx trv call:db --host localhost --port 3306 --username app --password <custom>
 ```
 
 ## VSCode Integration
-By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") does expose a cli target `web:http` that will show up, to help run/debug a web application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L84) decorator.  This means the target will be visible within the editor tooling.
+By default, cli commands do not expose themselves to the VSCode extension, as the majority of them are not intended for that sort of operation.  [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") does expose a cli target `web:http` that will show up, to help run/debug a web application.  Any command can mark itself as being a run target, and will be eligible for running from within the [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin). This is achieved by setting the `runTarget` field on the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/registry/decorator.ts#L85) decorator.  This means the target will be visible within the editor tooling.
 
 **Code: Simple Run Target**
 ```typescript
@@ -413,7 +413,6 @@ export class RunCommand {
 **Code: Anatomy of a Command**
 ```typescript
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
-
   /**
    * Parsed state
    */
@@ -458,15 +457,15 @@ export interface CliCommandShape<T extends unknown[] = unknown[]> {
 ```
 
 ### Dependency Injection
-If the goal is to run a more complex application, which may include depending on [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support."), we can take a look at [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.")'s target:
+If the goal is to run a more complex application, which may include depending on [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support."), we can take a look at [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications")'s target:
 
 **Code: Simple Run Target**
 ```typescript
-import { Runtime, ShutdownManager, toConcrete } from '@travetto/runtime';
-import { DependencyRegistry } from '@travetto/di';
+import { Runtime, toConcrete, Util } from '@travetto/runtime';
+import { DependencyRegistryIndex } from '@travetto/di';
 import { CliCommand, CliCommandShape } from '@travetto/cli';
 import { NetUtil } from '@travetto/web';
-import { RootRegistry } from '@travetto/registry';
+import { Registry } from '@travetto/registry';
 
 import type { WebHttpServer } from '../src/types.ts';
 
@@ -489,21 +488,16 @@ export class WebHttpCommand implements CliCommandShape {
   }
 
   async main(): Promise<void> {
-    await RootRegistry.init();
-    const instance = await DependencyRegistry.getInstance(toConcrete<WebHttpServer>());
-
-    let res;
-    try {
-      res = await instance.serve();
-    } catch (err) {
-      if (NetUtil.isPortUsedError(err) && !Runtime.production && this.killConflict) {
-        await NetUtil.freePort(err.port);
-        res = await instance.serve();
-      }
-      throw err;
-    }
-    ShutdownManager.onGracefulShutdown(res.kill, this);
-    return res.wait;
+    await Registry.init();
+    const instance = await DependencyRegistryIndex.getInstance(toConcrete<WebHttpServer>());
+
+    const handle = await Util.acquireWithRetry(
+      () => instance.serve(),
+      NetUtil.freePortOnConflict,
+      this.killConflict && !Runtime.production ? 5 : 1
+    );
+
+    return handle.complete;
   }
 }
 ```
@@ -513,7 +507,7 @@ As noted in the example above, `fields` is specified in this execution, with sup
 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.
 
 ### Custom Validation
-In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L32) errors that are returned will be shared with the user, and fail to invoke the `main` method.
+In addition to dependency injection, the command contract also allows for a custom validation function, which will have access to bound command (flags, and args) as well as the unknown arguments. When a command implements this method, any [CliValidationError](https://github.com/travetto/travetto/tree/main/module/cli/src/types.ts#L20) errors that are returned will be shared with the user, and fail to invoke the `main` method.
 
 **Code: CliValidationError**
 ```typescript
@@ -555,14 +549,14 @@ Options:
 
 Available Services
 --------------------
- * dynamodb@2.5.3
- * elasticsearch@8.17.0
+ * dynamodb@3.1.0
+ * elasticsearch@9.2.1
  * firestore@latest
- * mongodb@8.0
- * mysql@9.1
- * postgresql@17.2
- * redis@7.4
- * s3@3.12.0
+ * mongodb@8.2
+ * mysql@9.5
+ * postgresql@18.1
+ * redis@8.4
+ * s3@4.10.0
 ```
 
 A sample of all services available to the entire framework:
@@ -573,14 +567,14 @@ $ trv service status
 
 Service          Version    Status
 -------------------------------------------------
-dynamodb           2.5.3    Running 93af422e793a
-elasticsearch     8.17.0    Running ed76ee063d13
+dynamodb           3.1.0    Running 93af422e793a
+elasticsearch      9.2.1    Running ed76ee063d13
 firestore         latest    Running feec2e5e95b4
-mongodb              8.0    Running 5513eba6734e
-mysql                9.1    Running 307bc66d442a
-postgresql          17.2    Running e78291e71040
-redis                7.4    Running 77ba279b4e30
-s3                3.12.0    Running fdacfc55b9e3
+mongodb              8.2    Running 5513eba6734e
+mysql                9.5    Running 307bc66d442a
+postgresql          18.1    Running e78291e71040
+redis                8.4    Running 77ba279b4e30
+s3                4.10.0    Running fdacfc55b9e3
 ```
 
 ### Defining new Services
@@ -590,7 +584,7 @@ The services are defined as plain typescript files within the framework and can
 ```typescript
 import type { ServiceDescriptor } from '@travetto/cli';
 
-const version = process.env.MONGO_VERSION || '8.0';
+const version = process.env.MONGO_VERSION || '8.2';
 
 export const service: ServiceDescriptor = {
   name: 'mongodb',

package/__index__.ts

@@ -1,10 +1,12 @@
 import type { } from './src/trv.d.ts';
 export * from './src/types.ts';
-export * from './src/decorators.ts';
 export * from './src/execute.ts';
 export * from './src/error.ts';
 export * from './src/schema.ts';
-export * from './src/registry.ts';
+export * from './src/schema-export.ts';
+export * from './src/registry/decorator.ts';
+export * from './src/registry/registry-index.ts';
+export * from './src/registry/registry-adapter.ts';
 export * from './src/help.ts';
 export * from './src/color.ts';
 export * from './src/module.ts';

package/package.json

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

package/src/error.ts

@@ -11,7 +11,7 @@ const COMMAND_PACKAGE = [
   [/^openapi:(spec|client)$/, 'openapi', true],
   [/^email:(compile|editor)$/, 'email-compiler', false],
   [/^pack(:zip|:docker)?$/, 'pack', false],
-  [/^web:http$/, 'web-http-server', true],
+  [/^web:http$/, 'web-http', true],
   [/^web:rpc-client$/, 'web-rpc', true],
 ] as const;
 

package/src/execute.ts

@@ -1,7 +1,7 @@
 import { ConsoleManager, Runtime, ShutdownManager } from '@travetto/runtime';
 
 import { HelpUtil } from './help.ts';
-import { CliCommandRegistry } from './registry.ts';
+import { CliCommandRegistryIndex } from './registry/registry-index.ts';
 import { CliCommandSchemaUtil } from './schema.ts';
 import { CliUnknownCommandError, CliValidationResultError } from './error.ts';
 import { CliParseUtil } from './parse.ts';
@@ -33,9 +33,9 @@ export class ExecutionManager {
 
   /** Bind command  */
   static async #bindCommand(cmd: string, args: string[]): Promise<{ command: CliCommandShape, boundArgs: unknown[] }> {
-    const command = await CliCommandRegistry.getInstance(cmd, true);
-    const schema = await CliCommandSchemaUtil.getSchema(command);
+    const [{ instance: command, schema }] = await CliCommandRegistryIndex.load([cmd]);
     const fullArgs = await CliParseUtil.expandArgs(schema, args);
+
     const state = command._parsed = await CliParseUtil.parse(schema, fullArgs);
 
     await command.preBind?.();
@@ -75,7 +75,7 @@ export class ExecutionManager {
     } catch (err) {
       await this.#onError(err);
     } finally {
-      await ShutdownManager.gracefulShutdown();
+      await ShutdownManager.gracefulShutdown('@travetto/cli:execute');
     }
   }
 }

package/src/help.ts

@@ -1,20 +1,22 @@
 import util from 'node:util';
 
-import { castKey, castTo, Primitive } from '@travetto/runtime';
+import { castKey, getClass } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { cliTpl } from './color.ts';
 import { CliCommandShape } from './types.ts';
-import { CliCommandRegistry } from './registry.ts';
-import { CliCommandSchemaUtil } from './schema.ts';
+import { CliCommandRegistryIndex } from './registry/registry-index.ts';
 import { CliValidationResultError } from './error.ts';
-import { isBoolFlag } from './parse.ts';
+import { CliSchemaExportUtil } from './schema-export.ts';
 
-const validationSourceMap = {
-  custom: '',
+const validationSourceMap: Record<string, string> = {
   arg: 'Argument',
   flag: 'Flag'
 };
 
+const ifDefined = <T>(v: T | null | '' | undefined): T | undefined =>
+  (v === null || v === '' || v === undefined) ? undefined : v;
+
 /**
  * Utilities for showing help
  */
@@ -24,47 +26,51 @@ export class HelpUtil {
    * Render command-specific help
    * @param command
    */
-  static async renderCommandHelp(cmd: CliCommandShape | string): Promise<string> {
-    const command = typeof cmd === 'string' ? await CliCommandRegistry.getInstance(cmd, true) : cmd;
-    const commandName = CliCommandRegistry.getName(command);
+  static async renderCommandHelp(command: CliCommandShape): Promise<string> {
+    const schema = SchemaRegistryIndex.getConfig(getClass(command));
+    const { name: commandName } = CliCommandRegistryIndex.get(getClass(command));
+    const args = schema.methods.main?.parameters ?? [];
 
     await command.preHelp?.();
 
     // Ensure finalized
-    const { flags, args } = await CliCommandSchemaUtil.getSchema(command);
 
-    const usage: string[] = [cliTpl`${{ title: 'Usage:' }} ${{ param: commandName }} ${{ input: '[options]' }}`];
+    const usage: string[] = [cliTpl`${{ title: 'Usage:' }} ${{ param: commandName }} ${{ input: '[options]' }}`,];
     for (const field of args) {
-      const type = field.type === 'string' && field.choices && field.choices.length <= 7 ? field.choices?.join('|') : field.type;
+      const type = field.type === String && field.enum && field.enum?.values.length <= 7 ? field.enum?.values?.join('|') : field.type.name.toLowerCase();
       const arg = `${field.name}${field.array ? '...' : ''}:${type}`;
-      usage.push(cliTpl`${{ input: field.required ? `<${arg}>` : `[${arg}]` }}`);
+      usage.push(cliTpl`${{ input: field.required?.active !== false ? `<${arg}>` : `[${arg}]` }}`);
     }
 
     const params: string[] = [];
     const descriptions: string[] = [];
 
-    for (const flag of flags) {
-      const key = castKey<CliCommandShape>(flag.name);
-      const flagVal: Primitive = castTo(command[key]);
-
-      let aliases = flag.flagNames ?? [];
-      if (isBoolFlag(flag)) {
-        if (flagVal === true) {
-          aliases = (flag.flagNames ?? []).filter(x => !/^[-][^-]/.test(x));
-        } else {
-          aliases = (flag.flagNames ?? []).filter(x => !x.startsWith('--no-'));
-        }
-      }
-      const param = [cliTpl`${{ param: aliases.join(', ') }}`];
-      if (!isBoolFlag(flag)) {
-        const type = flag.type === 'string' && flag.choices && flag.choices.length <= 3 ? flag.choices?.join('|') : flag.type;
-        param.push(cliTpl`${{ type: `<${type}>` }}`);
+    for (const field of Object.values(schema.fields)) {
+      const key = castKey<CliCommandShape>(field.name);
+      const def = 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('--'))
+        );
+      let type: string | undefined;
+
+      if (field.type === String && field.enum && field.enum.values.length <= 3) {
+        type = field.enum.values?.join('|');
+      } else if (field.type !== Boolean) {
+        ({ type } = CliSchemaExportUtil.baseInputType(field));
       }
+
+      const param = [
+        cliTpl`${{ param: aliases.join(', ') }}`,
+        ...(type ? [cliTpl`${{ type: `<${type}>` }}`] : []),
+      ];
+
       params.push(param.join(' '));
-      const desc = [cliTpl`${{ title: flag.description }}`];
+      const desc = [cliTpl`${{ title: field.description }}`];
 
-      if (key !== 'help' && flagVal !== null && flagVal !== undefined && flagVal !== '') {
-        desc.push(cliTpl`(default: ${{ input: JSON.stringify(flagVal) }})`);
+      if (key !== 'help' && def !== undefined) {
+        desc.push(cliTpl`(default: ${{ input: JSON.stringify(def) }})`);
       }
       descriptions.push(desc.join(' '));
     }
@@ -76,7 +82,7 @@ export class HelpUtil {
     const descWidth = Math.max(...descWidths);
 
     const helpText = await (command.help?.() ?? []);
-    if (helpText.length && helpText[helpText.length - 1] !== '') {
+    if (helpText.length && helpText.at(-1) !== '') {
       helpText.push('');
     }
 
@@ -97,18 +103,15 @@ export class HelpUtil {
    */
   static async renderAllHelp(title?: string): Promise<string> {
     const rows: string[] = [];
-    const keys = [...CliCommandRegistry.getCommandMapping().keys()].toSorted((a, b) => a.localeCompare(b));
-    const maxWidth = keys.reduce((a, b) => Math.max(a, util.stripVTControlCharacters(b).length), 0);
 
-    for (const cmd of keys) {
+    // All
+    const resolved = await CliCommandRegistryIndex.load();
+    const maxWidth = resolved.reduce((a, b) => Math.max(a, util.stripVTControlCharacters(b.command).length), 0);
+
+    for (const { command: cmd, schema } of resolved) {
       try {
-        const inst = await CliCommandRegistry.getInstance(cmd);
-        if (inst) {
-          const cfg = await CliCommandRegistry.getConfig(inst);
-          if (!cfg.hidden) {
-            const schema = await CliCommandSchemaUtil.getSchema(cfg.cls);
-            rows.push(cliTpl`  ${{ param: cmd.padEnd(maxWidth, ' ') }} ${{ title: schema.title }}`);
-          }
+        if (schema && !schema.private) {
+          rows.push(cliTpl`  ${{ param: cmd.padEnd(maxWidth, ' ') }} ${{ title: schema.description || '' }}`);
         }
       } catch (err) {
         if (err instanceof Error) {
@@ -121,9 +124,8 @@ export class HelpUtil {
 
     const lines = [cliTpl`${{ title: 'Commands:' }}`, ...rows, ''];
 
-    if (title === undefined || title) {
-      lines.unshift(title ? cliTpl`${{ title }}` : cliTpl`${{ title: 'Usage:' }}  ${{ param: '[options]' }} ${{ param: '[command]' }}`, '');
-    }
+    lines.unshift(title ? cliTpl`${{ title }}` : cliTpl`${{ title: 'Usage:' }}  ${{ param: '[options]' }} ${{ param: '[command]' }}`, '');
+
     return lines.map(x => x.trimEnd()).join('\n');
   }
 
@@ -133,9 +135,12 @@ export class HelpUtil {
   static renderValidationError(err: CliValidationResultError): string {
     return [
       cliTpl`${{ failure: 'Execution failed' }}:`,
-      ...err.details.errors.map(e => e.source && e.source !== 'custom' ?
-        cliTpl` * ${{ identifier: validationSourceMap[e.source] }} ${{ subtitle: e.message }}` :
-        cliTpl` * ${{ failure: e.message }}`),
+      ...err.details.errors.map(e => {
+        if (e.source && e.source in validationSourceMap) {
+          return cliTpl` * ${{ identifier: validationSourceMap[e.source] }} ${{ subtitle: e.message }}`;
+        }
+        return cliTpl` * ${{ failure: e.message }}`;
+      }),
       '',
     ].join('\n');
   }

package/src/module.ts

@@ -98,4 +98,24 @@ export class CliModuleUtil {
     const graph = this.getDependencyGraph(mods);
     return graph[modName].includes(depModName);
   }
+
+  /**
+   * Find changed paths, either files between two git commits, or all folders for changed modules
+   */
+  static async findChangedPaths(config: { since?: string, changed?: boolean, logError?: boolean } = {}): Promise<string[]> {
+    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 [];
+      }
+    } else {
+      const mods = await this.findModules(config.changed ? 'changed' : 'workspace', undefined, 'HEAD');
+      return mods.map(x => x.sourcePath);
+    }
+  }
 }

package/src/parse.ts

@@ -2,7 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { Runtime } from '@travetto/runtime';
-import { CliCommandInput, CliCommandSchema, ParsedState } from './types.ts';
+import { SchemaClassConfig, SchemaFieldConfig, SchemaInputConfig } from '@travetto/schema';
+
+import { ParsedState } from './types.ts';
 
 type ParsedInput = ParsedState['all'][number];
 
@@ -11,27 +13,12 @@ const VALID_FLAG = /^-{1,2}[a-z]/i;
 const HELP_FLAG = /^-h|--help$/;
 const LONG_FLAG_WITH_EQ = /^--[a-z][^= ]+=\S+/i;
 const CONFIG_PRE = '+=';
-const ENV_PRE = 'env.';
 const SPACE = new Set([32, 7, 13, 10]);
 
-export const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
+export const ENV_PREFIX = 'env.';
+export const isBoolFlag = (x?: SchemaInputConfig): boolean => x?.type === Boolean && !x.array;
 
-const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: string, index?: number, value?: string }): ParsedInput => {
-  const { field, input, rawText = input, value, index } = cfg;
-  if (!field) {
-    return { type: 'unknown', input: rawText };
-  } else if (!field.flagNames?.length) {
-    return { type: 'arg', input: field ? input : rawText ?? input, array: field.array, index: index! };
-  } else {
-    return {
-      type: 'flag',
-      fieldName: field.name,
-      array: field.array,
-      input: field ? input : rawText ?? input,
-      value: value ?? (isBoolFlag(field) ? !input.startsWith('--no-') : undefined)
-    };
-  }
-};
+export type AliasesParseResult = Record<'long' | 'short' | 'raw' | 'env', string[]>;
 
 /**
  * Parsing support for the cli
@@ -39,7 +26,7 @@ const getInput = (cfg: { field?: CliCommandInput, rawText?: string, input: strin
 export class CliParseUtil {
 
   static toEnvField(k: string): string {
-    return `${ENV_PRE}${k}`;
+    return k.startsWith(ENV_PREFIX) ? k : `${ENV_PREFIX}${k}`;
   }
 
   static readToken(text: string, start = 0): { next: number, value?: string } {
@@ -80,11 +67,11 @@ export class CliParseUtil {
   /**
    * Get a user-specified module if present
    */
-  static getSpecifiedModule(schema: CliCommandSchema, args: string[]): string | undefined {
+  static getSpecifiedModule(schema: SchemaClassConfig, args: string[]): string | undefined {
     const SEP = args.includes(RAW_SEP) ? args.indexOf(RAW_SEP) : args.length;
-    const input = schema.flags.find(x => x.type === 'module');
-    const ENV_KEY = input?.flagNames?.filter(x => x.startsWith(ENV_PRE)).map(x => x.replace(ENV_PRE, ''))[0] ?? '';
-    const flags = new Set(input?.flagNames ?? []);
+    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 flags = new Set(input?.aliases ?? []);
     const check = (k?: string, v?: string): string | undefined => flags.has(k!) ? v : undefined;
     return args.reduce(
       (m, x, i, arr) =>
@@ -144,7 +131,7 @@ export class CliParseUtil {
   /**
    * Expand flag arguments into full argument list
    */
-  static async expandArgs(schema: CliCommandSchema, args: string[]): Promise<string[]> {
+  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) =>
@@ -154,22 +141,23 @@ export class CliParseUtil {
   /**
    * Parse inputs to command
    */
-  static async parse(schema: CliCommandSchema, inputs: string[]): Promise<ParsedState> {
-    const flagMap = new Map<string, CliCommandInput>(
-      schema.flags.flatMap(f => (f.flagNames ?? []).map(name => [name, f]))
+  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]))
     );
 
     const out: ParsedInput[] = [];
 
     // Load env vars to front
-    for (const field of schema.flags) {
-      for (const envName of field.envVars ?? []) {
-        if (envName in process.env) {
-          const value: string = process.env[envName]!;
+    for (const field of Object.values(schema.fields)) {
+      for (const envName of (field.aliases ?? []).filter(x => x.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 => getInput({ field, input: `${ENV_PRE}${envName}`, value: v })));
+            out.push(...value.split(/\s*,\s*/g).map(v => ({ type: 'flag', fieldName: field.name.toString(), input: envName, value: v }) as const));
           } else {
-            out.push(getInput({ field, input: `${ENV_PRE}${envName}`, value }));
+            out.push({ type: 'flag', fieldName: field.name.toString(), input: envName, value });
           }
         }
       }
@@ -181,24 +169,37 @@ export class CliParseUtil {
       const input = inputs[i];
 
       if (input === RAW_SEP) { // Raw separator
-        out.push(...inputs.slice(i + 1).map(x => getInput({ input: x })));
+        out.push(...inputs.slice(i + 1).map((x, idx) => ({ type: 'unknown', input: x, index: argIdx + idx }) as const));
         break;
       } else if (LONG_FLAG_WITH_EQ.test(input)) {
         const [k, ...v] = input.split('=');
         const field = flagMap.get(k);
-        out.push(getInput({ field, rawText: input, input: k, value: v.join('=') }));
+        if (field) {
+          out.push({ type: 'flag', fieldName: field.name.toString(), input: k, value: v.join('=') });
+        } else {
+          out.push({ type: 'unknown', input });
+        }
       } else if (VALID_FLAG.test(input)) { // Flag
         const field = flagMap.get(input);
-        const next = inputs[i + 1];
-        if ((next && (VALID_FLAG.test(next) || next === RAW_SEP)) || isBoolFlag(field)) {
-          out.push(getInput({ field, input }));
+        if (!field) {
+          out.push({ type: 'unknown', input });
         } else {
-          out.push(getInput({ field, input, value: next }));
-          i += 1;
+          const next = inputs[i + 1];
+          const base = { type: 'flag', fieldName: field.name.toString(), 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-') });
+            } else {
+              out.push(base);
+            }
+          } else {
+            out.push({ ...base, value: next });
+            i += 1;
+          }
         }
       } else {
-        const field = schema.args[argIdx];
-        out.push(getInput({ field, input, index: argIdx }));
+        const field = schema.methods.main?.parameters[argIdx];
+        out.push({ type: 'arg', array: field?.array ?? false, input, index: argIdx });
         // Move argIdx along if not in a var arg situation
         if (!field?.array) {
           argIdx += 1;
@@ -214,4 +215,24 @@ export class CliParseUtil {
       flags: out.filter(x => x.type === 'flag')
     };
   }
+
+  /**
+   * 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);
+        } else {
+          acc.short.push(curr);
+        }
+      } else if (curr.startsWith(ENV_PREFIX)) {
+        acc.env.push(curr);
+      } else {
+        acc.raw.push(curr);
+      }
+      return acc;
+    }, { long: [], short: [], raw: [], env: [] });
+  }
 }