@travetto/cli 5.0.0-rc.1 → 5.0.0-rc.11

package/README.md

@@ -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#L15) decorator
+   *  The class must use the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) decorator
 
 **Code: Basic Command**
 ```typescript
@@ -93,7 +93,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#L15) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L15) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) 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/decorators.ts#L85) is a wrapper for [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14), and so every class that uses the [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L85) decorator is now a full [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) class. The fields of the class represent the flags that are available to the command.
 
 **Code: Basic Command with Flag**
 ```typescript
@@ -130,11 +130,11 @@ $ trv basic:flag --loud
 HELLO
 ```
 
-The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.ts#L15) supports the following data types for flags:
+The [@CliCommand](https://github.com/travetto/travetto/tree/main/module/cli/src/decorators.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#L172), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L178), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L166), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) decorators help provide additional validation.
-   *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L99) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L78) provide additional constraints
-   *  Date values. The [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L107) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L117) decorators help provide additional validation.
+   *  Number values. The [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L171), [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L177), [@Precision](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L165), [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) decorators help provide additional validation.
+   *  String values. [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106), [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116), [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L98) and [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L77) provide additional constraints
+   *  Date values. The [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L106) and [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) decorators help provide additional validation.
    *  String lists. Same as String, but allowing multiple values.
    *  Numeric lists. Same as Number, but allowing multiple values.
 
@@ -388,7 +388,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.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest 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#L15) 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.  [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") does expose a cli target `run:rest` that will show up, to help run/debug a rest 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#L85) decorator.  This means the target will be visible within the editor tooling.
 
 **Code: Simple Run Target**
 ```typescript
@@ -411,6 +411,7 @@ export class RunCommand {
 **Code: Anatomy of a Command**
 ```typescript
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
+
   /**
    * Parsed state
    */
@@ -459,9 +460,9 @@ If the goal is to run a more complex application, which may include depending on
 
 **Code: Simple Run Target**
 ```typescript
-import { Env } from '@travetto/base';
+import { Runtime } from '@travetto/runtime';
 import { DependencyRegistry } from '@travetto/di';
-import { CliCommand, CliCommandShape, CliUtil } from '@travetto/cli';
+import { CliCommand, CliCommandShape } from '@travetto/cli';
 
 import { ServerHandle } from '../src/types';
 import { RestNetUtil } from '../src/util/net';
@@ -469,15 +470,9 @@ import { RestNetUtil } from '../src/util/net';
 /**
  * Run a rest server as an application
  */
-@CliCommand({ runTarget: true, addModule: true, addEnv: true })
+@CliCommand({ runTarget: true, with: { debugIpc: true, canRestart: true, module: true, env: true } })
 export class RunRestCommand implements CliCommandShape {
 
-  /** IPC debug is enabled */
-  debugIpc?: boolean;
-
-  /** Should the server be able to run with restart*/
-  canRestart?: boolean;
-
   /** Port to run on */
   port?: number;
 
@@ -491,14 +486,11 @@ export class RunRestCommand implements CliCommandShape {
   }
 
   async main(): Promise<ServerHandle | void> {
-    if (await CliUtil.debugIfIpc(this) || await CliUtil.runWithRestart(this)) {
-      return;
-    }
     const { RestApplication } = await import('../src/application/rest');
     try {
       return await DependencyRegistry.runInstance(RestApplication);
     } catch (err) {
-      if (RestNetUtil.isInuseError(err) && !Env.production && this.killConflict) {
+      if (RestNetUtil.isInuseError(err) && !Runtime.production && this.killConflict) {
         await RestNetUtil.freePort(err.port);
         return await DependencyRegistry.runInstance(RestApplication);
       }
@@ -508,7 +500,7 @@ export class RunRestCommand 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/base/src/env.ts#L116) `name` defined in the [Base](https://github.com/travetto/travetto/tree/main/module/base#readme "Environment config and common utilities 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/env.ts#L109) `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/package.json

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

package/src/decorators.ts

@@ -1,11 +1,81 @@
-import { Class, ClassInstance, Env, RuntimeContext } from '@travetto/base';
-import { RuntimeIndex } from '@travetto/manifest';
-import { SchemaRegistry } from '@travetto/schema';
+import { Class, ClassInstance, Env, Runtime, RuntimeIndex, describeFunction } from '@travetto/runtime';
+import { FieldConfig, SchemaRegistry } from '@travetto/schema';
 
 import { CliCommandShape, CliCommandShapeFields } from './types';
-import { CliCommandRegistry, CliCommandConfigOptions } from './registry';
+import { CliCommandRegistry } from './registry';
 import { CliModuleUtil } from './module';
 import { CliParseUtil } from './parse';
+import { CliUtil } from './util';
+
+type Cmd = CliCommandShape & { env?: string };
+
+type CliCommandConfigOptions = {
+  hidden?: boolean;
+  runTarget?: boolean;
+  runtimeModule?: 'current' | 'command';
+  with?: {
+    /** Application environment */
+    env?: boolean;
+    /** Module to run for */
+    module?: boolean;
+    /** Should debug invocation trigger via ipc */
+    debugIpc?: boolean;
+    /** Should the invocation automatically restart on exit */
+    canRestart?: boolean;
+  };
+};
+
+const FIELD_CONFIG: {
+  name: keyof Exclude<CliCommandConfigOptions['with'], undefined>;
+  field: Partial<FieldConfig>;
+  run: (cmd: Cmd) => (Promise<unknown> | unknown);
+}[] =
+  [
+    {
+      name: 'env',
+      run: cmd => Env.TRV_ENV.set(cmd.env || Runtime.env),
+      field: {
+        type: String,
+        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
+        description: 'Application environment',
+        required: { active: false },
+      },
+    },
+    {
+      name: 'module',
+      run: (): void => { },
+      field: {
+        type: String,
+        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
+        description: 'Module to run for',
+        specifiers: ['module'],
+        required: { active: Runtime.monoRoot },
+      },
+    },
+    {
+      name: 'debugIpc',
+      run: cmd => CliUtil.debugIfIpc(cmd).then((v) => v && process.exit(0)),
+      field: {
+        type: Boolean,
+        aliases: ['di'],
+        description: 'Should debug invocation trigger via ipc',
+        default: true,
+        required: { active: false },
+      },
+    },
+    {
+      name: 'canRestart',
+      run: cmd => CliUtil.runWithRestart(cmd)?.then((v) => v && process.exit(0)),
+      field: {
+        type: Boolean,
+        aliases: ['cr'],
+        description: 'Should the invocation automatically restart on exit',
+        default: false,
+        required: { active: false },
+      },
+    }
+  ];
+
 
 /**
  * Decorator to register a CLI command
@@ -14,54 +84,39 @@ import { CliParseUtil } from './parse';
  */
 export function CliCommand(cfg: CliCommandConfigOptions = {}) {
   return function <T extends CliCommandShape>(target: Class<T>): void {
-    const meta = RuntimeIndex.getFunctionMetadata(target);
-    if (!meta || meta.abstract) {
+    if (!target.Ⲑid || describeFunction(target)?.abstract) {
       return;
     }
 
-    const addModule = cfg.addModule === true || cfg.fields?.includes('module');
-    const runtimeModule = cfg.runtimeModule ?? (cfg.addModule ? 'current' : undefined);
-    const addEnv = cfg.addEnv ?? cfg.fields?.includes('env');
+    const VALID_FIELDS = FIELD_CONFIG.filter(f => !!cfg.with?.[f.name]);
+
     const { commandModule } = CliCommandRegistry.registerClass(target, {
       hidden: cfg.hidden,
       runTarget: cfg.runTarget,
-      preMain: async (cmd: CliCommandShape & { env?: string }) => {
-        if (addEnv) {
-          Env.TRV_ENV.set(cmd.env || Env.name);
+      preMain: async (cmd: Cmd) => {
+        for (const field of VALID_FIELDS) {
+          await field.run(cmd);
         }
       }
     });
 
     const pendingCls = SchemaRegistry.getOrCreatePending(target);
 
-    if (addEnv) {
-      SchemaRegistry.registerPendingFieldConfig(target, 'env', String, {
-        aliases: ['e', CliParseUtil.toEnvField(Env.TRV_ENV.key)],
-        description: 'Application environment',
-        required: { active: false }
-      });
+    for (const { name, field: { type, ...field } } of VALID_FIELDS) {
+      SchemaRegistry.registerPendingFieldConfig(target, name, type!, field);
     }
 
-    if (addModule) {
-      SchemaRegistry.registerPendingFieldConfig(target, 'module', String, {
-        aliases: ['m', CliParseUtil.toEnvField(Env.TRV_MODULE.key)],
-        description: 'Module to run for',
-        specifiers: ['module'],
-        required: { active: RuntimeContext.monoRoot }
-      });
-    }
+    const runtimeModule = cfg.runtimeModule ?? (cfg.with?.module ? 'current' : undefined);
 
     if (runtimeModule) { // Validate module
-      (pendingCls.validators ??= []).push(async item => {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const { module: mod } = item as CliCommandShapeFields;
-        const runModule = (runtimeModule === 'command' ? commandModule : mod) || RuntimeContext.main.name;
+      (pendingCls.validators ??= []).push(async ({ module: mod }: Partial<CliCommandShapeFields>) => {
+        const runModule = (runtimeModule === 'command' ? commandModule : mod) || Runtime.main.name;
 
         // If we need to run as a specific module
-        if (runModule !== RuntimeContext.main.name) {
+        if (runModule !== Runtime.main.name) {
           try {
             RuntimeIndex.reinitForModule(runModule);
-          } catch (err) {
+          } catch {
             return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: '.' };
           }
         }

package/src/error.ts

@@ -1,4 +1,4 @@
-import { AppError, RuntimeContext } from '@travetto/base';
+import { AppError, Runtime } from '@travetto/runtime';
 import { PackageUtil } from '@travetto/manifest';
 import { cliTpl } from './color';
 import { CliValidationError, CliCommandShape } from './types';
@@ -23,7 +23,7 @@ export class CliUnknownCommandError extends Error {
     const matchedCfg = COMMAND_PACKAGE.find(([re]) => re.test(cmd));
     if (matchedCfg) {
       const [, pkg, prod] = matchedCfg;
-      const install = PackageUtil.getInstallCommand(RuntimeContext, `@travetto/${pkg}`, prod);
+      const install = PackageUtil.getInstallCommand(Runtime, `@travetto/${pkg}`, prod);
       return cliTpl`
 ${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
 ${{ identifier: install }}

package/src/execute.ts

@@ -1,4 +1,4 @@
-import { ConsoleManager, Env, ShutdownManager } from '@travetto/base';
+import { ConsoleManager, Runtime, ShutdownManager } from '@travetto/runtime';
 
 import { HelpUtil } from './help';
 import { CliCommandRegistry } from './registry';
@@ -54,7 +54,7 @@ export class ExecutionManager {
     await command._cfg!.preMain?.(command);
     await command.preMain?.();
 
-    ConsoleManager.debug(Env.debug);
+    ConsoleManager.debug(Runtime.debug);
     const result = await command.main(...boundArgs);
     await CliUtil.listenForResponse(result);
   }

package/src/help.ts

@@ -1,6 +1,6 @@
 import util from 'node:util';
 
-import { Primitive } from '@travetto/schema';
+import { castKey, castTo, Primitive } from '@travetto/runtime';
 
 import { cliTpl } from './color';
 import { CliCommandShape } from './types';
@@ -41,13 +41,11 @@ export class HelpUtil {
     }
 
     const params: string[] = [];
-    const descs: string[] = [];
+    const descriptions: string[] = [];
 
     for (const flag of flags) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const key = flag.name as keyof CliCommandShape;
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const flagVal = command[key] as unknown as Primitive;
+      const key = castKey<CliCommandShape>(flag.name);
+      const flagVal: Primitive = castTo(command[key]);
 
       let aliases = flag.flagNames ?? [];
       if (isBoolFlag(flag)) {
@@ -68,11 +66,11 @@ export class HelpUtil {
       if (key !== 'help' && flagVal !== null && flagVal !== undefined && flagVal !== '') {
         desc.push(cliTpl`(default: ${{ input: JSON.stringify(flagVal) }})`);
       }
-      descs.push(desc.join(' '));
+      descriptions.push(desc.join(' '));
     }
 
     const paramWidths = params.map(x => util.stripVTControlCharacters(x).length);
-    const descWidths = descs.map(x => util.stripVTControlCharacters(x).length);
+    const descWidths = descriptions.map(x => util.stripVTControlCharacters(x).length);
 
     const paramWidth = Math.max(...paramWidths);
     const descWidth = Math.max(...descWidths);
@@ -87,7 +85,7 @@ export class HelpUtil {
       '',
       cliTpl`${{ title: 'Options:' }}`,
       ...params.map((_, i) =>
-        `  ${params[i]}${' '.repeat((paramWidth - paramWidths[i]))}  ${descs[i].padEnd(descWidth)}${' '.repeat((descWidth - descWidths[i]))}`
+        `  ${params[i]}${' '.repeat((paramWidth - paramWidths[i]))}  ${descriptions[i].padEnd(descWidth)}${' '.repeat((descWidth - descWidths[i]))}`
       ),
       '',
       ...helpText

package/src/module.ts

@@ -1,5 +1,5 @@
-import { RuntimeContext } from '@travetto/base';
-import { type IndexedModule, RuntimeIndex } from '@travetto/manifest';
+import { Runtime, RuntimeIndex } from '@travetto/runtime';
+import type { IndexedModule } from '@travetto/manifest';
 
 import { CliScmUtil } from './scm';
 
@@ -44,11 +44,11 @@ export class CliModuleUtil {
    * @param transitive
    * @returns
    */
-  static async findModules(mode: 'all' | 'changed', fromHash?: string, toHash?: string, emptyOnFail = false): Promise<IndexedModule[]> {
+  static async findModules(mode: 'all' | 'changed', fromHash?: string, toHash?: string): Promise<IndexedModule[]> {
     return (mode === 'changed' ?
-      await this.findChangedModulesRecursive(fromHash, toHash, emptyOnFail) :
+      await this.findChangedModulesRecursive(fromHash, toHash, true) :
       [...RuntimeIndex.getModuleList('all')].map(x => RuntimeIndex.getModule(x)!)
-    ).filter(x => x.sourcePath !== RuntimeContext.workspace.path);
+    ).filter(x => x.sourcePath !== Runtime.workspace.path);
   }
 
   /**

package/src/parse.ts

@@ -1,8 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { RuntimeContext } from '@travetto/base';
-import { RuntimeIndex } from '@travetto/manifest';
+import { Runtime } from '@travetto/runtime';
 import { CliCommandInput, CliCommandSchema, ParsedState } from './types';
 
 type ParsedInput = ParsedState['all'][number];
@@ -86,16 +85,8 @@ export class CliParseUtil {
     const key = flag.replace(CONFIG_PRE, '');
 
     // We have a file
-    const rel = (key.includes('/') ? key : `@/support/pack.${key}.flags`)
-      .replace('@@/', `${RuntimeContext.workspace.path}/`)
-      .replace('@/', `${mod}/`)
-      .replace(/^(@[^\/]+\/[^\/]+)(\/.*)$/, (_, imp, rest) => {
-        const val = RuntimeIndex.getModule(imp);
-        if (!val) {
-          throw new Error(`Unknown module file: ${_}, unable to proceed`);
-        }
-        return `${val.sourcePath}${rest}`;
-      });
+    const rel = (key.includes('/') ? key : `@#support/pack.${key}.flags`)
+      .replace(/^(@[^#]*)#(.*)$/, (_, imp, rest) => `${Runtime.modulePath(imp)}/${rest}`);
 
     const file = path.resolve(rel);
 
@@ -146,7 +137,7 @@ export class CliParseUtil {
     const mod = args.reduce(
       (m, x, i, arr) =>
         (i < SEP ? check(arr[i - 1], x) ?? check(...x.split('=')) : undefined) ?? m,
-      process.env[ENV_KEY] || RuntimeContext.main.name
+      process.env[ENV_KEY] || Runtime.main.name
     );
     return (await Promise.all(args.map((x, i) =>
       x.startsWith(CONFIG_PRE) && (i < SEP || SEP < 0) ? this.readFlagFile(x, mod) : x))).flat();
@@ -200,7 +191,7 @@ export class CliParseUtil {
       } else {
         const field = schema.args[argIdx];
         out.push(getInput({ field, input, index: argIdx }));
-        // Move argIdx along if not in a vararg situation
+        // Move argIdx along if not in a var arg situation
         if (!field?.array) {
           argIdx += 1;
         }

package/src/registry.ts

@@ -1,20 +1,9 @@
-import { Class, ConcreteClass, Env } from '@travetto/base';
-import { RuntimeIndex } from '@travetto/manifest';
+import { asConstructable, Class, classConstruct, describeFunction, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { CliCommandConfig, CliCommandShape } from './types';
 import { CliUnknownCommandError } from './error';
 
-export type CliCommandConfigOptions = {
-  hidden?: boolean;
-  runTarget?: boolean;
-  addModule?: boolean;
-  addEnv?: boolean;
-  runtimeModule?: 'current' | 'command';
-  /** @deprecated */
-  fields?: ('module' | 'env')[];
-};
-
-const CLI_FILE_REGEX = /\/cli[.](?<name>.*)[.]tsx?$/;
+const CLI_FILE_REGEX = /\/cli[.](?<name>.*?)([.]tsx?)?$/;
 const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
 
 class $CliCommandRegistry {
@@ -25,9 +14,8 @@ class $CliCommandRegistry {
     return this.#commands.get(cls);
   }
 
-  #getClass(cmd: CliCommandShape): Class<CliCommandShape> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return cmd.constructor as Class;
+  getClass(cmd: CliCommandShape): Class<CliCommandShape> {
+    return asConstructable<CliCommandShape>(cmd).constructor;
   }
 
   /**
@@ -37,7 +25,7 @@ class $CliCommandRegistry {
     if (!this.#fileMapping) {
       const all = new Map<string, string>();
       for (const e of RuntimeIndex.find({
-        module: m => !Env.production || m.prod,
+        module: m => !Runtime.production || m.prod,
         folder: f => f === 'support',
         file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
       })) {
@@ -51,13 +39,12 @@ class $CliCommandRegistry {
   /**
    * Registers a cli command
    */
-  registerClass(cls: Class, cfg: Partial<CliCommandConfig>): CliCommandConfig {
-    const source = RuntimeIndex.getFunctionMetadata(cls)!.source;
+  registerClass<T extends CliCommandShape>(cls: Class<T>, cfg: Partial<CliCommandConfig>): CliCommandConfig {
+    const meta = describeFunction(cls);
     this.#commands.set(cls, {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      cls: cls as ConcreteClass,
-      name: getName(source),
-      commandModule: RuntimeIndex.getModuleFromSource(source)!.name,
+      cls,
+      name: getName(meta.import),
+      commandModule: meta.module,
       ...cfg,
     });
     return this.#commands.get(cls)!;
@@ -67,7 +54,7 @@ class $CliCommandRegistry {
    * Get config for a given instance
    */
   getConfig(cmd: CliCommandShape): CliCommandConfig {
-    return this.getByClass(this.#getClass(cmd))!;
+    return this.getByClass(this.getClass(cmd))!;
   }
 
   /**
@@ -87,11 +74,11 @@ class $CliCommandRegistry {
   async getInstance(name: string, failOnMissing = false): Promise<CliCommandShape | undefined> {
     const found = this.getCommandMapping().get(name);
     if (found) {
-      const values = Object.values<Class>(await import(found));
+      const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
       for (const v of values) {
         const cfg = this.getByClass(v);
         if (cfg) {
-          const inst = new cfg.cls();
+          const inst = classConstruct(cfg.cls);
           if (!inst.isActive || inst.isActive()) {
             inst._cfg = this.getConfig(inst);
             return inst;

package/src/schema.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { castKey, castTo, Class } from '@travetto/runtime';
 import { BindUtil, FieldConfig, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
 import { CliCommandRegistry } from './registry';
@@ -52,8 +52,7 @@ export class CliCommandSchemaUtil {
    * Get schema for a given command
    */
   static async getSchema(src: Class | CliCommandShape): Promise<CliCommandSchema> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const cls = 'main' in src ? src.constructor as Class : src;
+    const cls = 'main' in src ? CliCommandRegistry.getClass(src) : src;
     if (this.#schemas.has(cls)) {
       return this.#schemas.get(cls)!;
     }
@@ -127,22 +126,18 @@ export class CliCommandSchemaUtil {
     for (const arg of state.all) {
       switch (arg.type) {
         case 'flag': {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const key = arg.fieldName as keyof T;
+          const key = castKey<T>(arg.fieldName);
           const value = arg.value!;
           if (arg.array) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            ((template[key] as unknown[]) ??= []).push(value);
+            castTo<unknown[]>(template[key] ??= castTo([])).push(value);
           } else {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            template[key] = value as unknown as T[typeof key];
+            template[key] = castTo(value);
           }
           break;
         }
         case 'arg': {
           if (arg.array) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            ((bound[arg.index] ??= []) as unknown[]).push(arg.input);
+            castTo<unknown[]>(bound[arg.index] ??= []).push(arg.input);
           } else {
             bound[arg.index] = arg.input;
           }
@@ -150,8 +145,7 @@ export class CliCommandSchemaUtil {
       }
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const cls = cmd.constructor as Class<CliCommandShape>;
+    const cls = CliCommandRegistry.getClass(cmd);
     BindUtil.bindSchemaToObject(cls, cmd, template);
     return BindUtil.coerceMethodParams(cls, 'main', bound);
   }
@@ -160,9 +154,7 @@ export class CliCommandSchemaUtil {
    * Validate command shape with the given arguments
    */
   static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const cls = cmd.constructor as Class<CliCommandShape>;
-
+    const cls = CliCommandRegistry.getClass(cmd);
     const paramNames = SchemaRegistry.getMethodSchema(cls, 'main').map(x => x.name);
 
     const validators = [

package/src/scm.ts

@@ -2,8 +2,8 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { ExecUtil, RuntimeContext } from '@travetto/base';
-import { type IndexedModule, RuntimeIndex } from '@travetto/manifest';
+import { AppError, ExecUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
+import type { IndexedModule } from '@travetto/manifest';
 
 export class CliScmUtil {
   /**
@@ -35,7 +35,7 @@ export class CliScmUtil {
    * @returns
    */
   static async findLastRelease(): Promise<string | undefined> {
-    const result = await ExecUtil.getResult(spawn('git', ['log', '--pretty=oneline'], { cwd: RuntimeContext.workspace.path }));
+    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];
@@ -46,12 +46,11 @@ export class CliScmUtil {
    * @param fromHash
    * @returns
    */
-  static async findChangedFiles(fromHash: string, toHash: string = 'HEAD', emptyOnFail = false): Promise<string[]> {
-    const ws = RuntimeContext.workspace.path;
+  static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
+    const ws = Runtime.workspace.path;
     const res = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: ws }), { catch: true });
-    if (!res.valid && emptyOnFail) {
-      console.warn('Unable to detect changes between', fromHash, toHash, 'with', (res.stderr || res.stdout));
-      return [];
+    if (!res.valid) {
+      throw new AppError('Unable to detect changes between', 'data', { fromHash, toHash, output: (res.stderr || res.stdout) });
     }
     const out = new Set<string>();
     for (const line of res.stdout.split(/\n/g)) {

package/src/trv.d.ts

@@ -1,4 +1,4 @@
-import '@travetto/base';
+import '@travetto/runtime';
 
 declare global {
   interface TravettoEnv {

package/src/types.ts

@@ -1,4 +1,4 @@
-import { ConcreteClass } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 
 type OrProm<T> = T | Promise<T>;
 
@@ -19,7 +19,7 @@ export type CliCommandConfig = {
   name: string;
   commandModule: string;
   runTarget?: boolean;
-  cls: ConcreteClass<CliCommandShape>;
+  cls: Class<CliCommandShape>;
   hidden?: boolean;
   preMain?: (cmd: CliCommandShape) => void | Promise<void>;
 };
@@ -49,6 +49,7 @@ export type CliValidationError = {
  * CLI Command Contract
  */
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
+
   /**
    * Parsed state
    */
@@ -116,7 +117,7 @@ export type CliCommandShapeFields = {
 /**
  * CLI Command argument/flag shape
  */
-export type CliCommandInput = {
+export type CliCommandInput<K extends string = string> = {
   name: string;
   description?: string;
   type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
@@ -125,19 +126,19 @@ export type CliCommandInput = {
   required?: boolean;
   array?: boolean;
   default?: unknown;
-  flagNames?: string[];
+  flagNames?: K[];
   envVars?: string[];
 };
 
 /**
  * CLI Command schema shape
  */
-export type CliCommandSchema = {
+export interface CliCommandSchema<K extends string = string> {
   name: string;
   title: string;
   commandModule: string;
   runTarget?: boolean;
   description?: string;
   args: CliCommandInput[];
-  flags: CliCommandInput[];
-};
+  flags: CliCommandInput<K>[];
+}

package/src/util.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 
-import { Env, ExecUtil, ShutdownManager, RuntimeContext } from '@travetto/base';
+import { Env, ExecUtil, ShutdownManager, Runtime } from '@travetto/runtime';
 
 import { CliCommandShape, CliCommandShapeFields, RunResponse } from './types';
 
@@ -14,10 +14,10 @@ export class CliUtil {
    * @returns
    */
   static getSimpleModuleName(placeholder: string, module?: string): string {
-    const simple = (module ?? RuntimeContext.main.name).replace(/[\/]/, '_').replace(/@/, '');
+    const simple = (module ?? Runtime.main.name).replace(/[\/]/, '_').replace(/@/, '');
     if (!simple) {
       return placeholder;
-    } else if (!module && RuntimeContext.monoRoot) {
+    } else if (!module && Runtime.monoRoot) {
       return placeholder;
     } else {
       return placeholder.replace('<module>', simple);
@@ -31,7 +31,7 @@ export class CliUtil {
     if (ipc && process.connected) {
       process.once('disconnect', () => process.exit());
     }
-    if (Env.TRV_CAN_RESTART.isFalse || !(cmd.canRestart ?? !Env.production)) {
+    if (Env.TRV_CAN_RESTART.isFalse || !(cmd.canRestart ?? !Runtime.production)) {
       Env.TRV_CAN_RESTART.clear();
       return;
     }
@@ -64,7 +64,7 @@ export class CliUtil {
       data: {
         name: cmd._cfg!.name, env,
         commandModule: cmd._cfg!.commandModule,
-        module: RuntimeContext.main.name,
+        module: Runtime.main.name,
         args: process.argv.slice(3),
       }
     };
@@ -79,7 +79,7 @@ export class CliUtil {
    * Debug if IPC available
    */
   static async debugIfIpc<T extends CliCommandShapeFields & CliCommandShape>(cmd: T): Promise<boolean> {
-    return (cmd.debugIpc ?? !Env.production) && this.triggerIpc('run', cmd);
+    return (cmd.debugIpc ?? !Runtime.production) && this.triggerIpc('run', cmd);
   }
 
   /**

package/support/cli.cli_schema.ts

@@ -1,4 +1,4 @@
-import { Env } from '@travetto/base';
+import { Env } from '@travetto/runtime';
 
 import { CliCommand } from '../src/decorators';
 import { CliCommandSchema, CliCommandShape, CliValidationError } from '../src/types';

package/support/cli.main.ts

@@ -1,9 +1,5 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import { RuntimeContext } from '@travetto/base';
+import { Runtime } from '@travetto/runtime';
 import { CliCommandShape, CliCommand, CliValidationError, ParsedState } from '@travetto/cli';
-import { RuntimeIndex } from '@travetto/manifest';
 import { Ignore } from '@travetto/schema';
 
 /**
@@ -15,19 +11,10 @@ export class MainCommand implements CliCommandShape {
   @Ignore()
   _parsed: ParsedState;
 
-  async #getImport(fileOrImport: string): Promise<string | undefined> {
-    // If referenced file exists
-    let file = fileOrImport;
-    if (await (fs.stat(path.resolve(fileOrImport)).then(() => true, () => false))) {
-      file = path.join(RuntimeContext.main.name, fileOrImport);
-    }
-
-    return RuntimeIndex.getFromImport(file)?.import;
-  }
-
   async validate(fileOrImport: string): Promise<CliValidationError | undefined> {
-    const imp = await this.#getImport(fileOrImport);
-    if (!imp) {
+    try {
+      await Runtime.importFrom(fileOrImport);
+    } catch {
       return { message: `Unknown file: ${fileOrImport}` };
     }
   }
@@ -35,8 +22,7 @@ export class MainCommand implements CliCommandShape {
   async main(fileOrImport: string, args: string[] = []): Promise<void> {
     let res: unknown;
     try {
-      const imp = await this.#getImport(fileOrImport);
-      const mod = await import(imp!);
+      const mod = await Runtime.importFrom<{ main(..._: unknown[]): Promise<unknown> }>(fileOrImport);
       res = await mod.main(...args, ...this._parsed.unknown);
     } catch (err) {
       res = err;

package/support/transformer.cli.ts

@@ -20,16 +20,16 @@ export class CliCommandTransformer {
     }
 
     // Find runnable method
-    const runMethod = node.members
+    const mainMethod = node.members
       .find((x): x is ts.MethodDeclaration =>
         ts.isMethodDeclaration(x) && x.name!.getText() === 'main'
       );
 
-    if (!runMethod) {
+    if (!mainMethod) {
       return node;
     }
 
-    const members = node.members.map(x => ts.isMethodDeclaration(x) && x === runMethod ?
+    const members = node.members.map(x => ts.isMethodDeclaration(x) && x === mainMethod ?
       state.factory.updateMethodDeclaration(
         x,
         x.modifiers,