@travetto/cli 6.0.1 → 7.0.0-rc.1

package/src/registry/decorator.ts

@@ -0,0 +1,153 @@
+import { Class, ClassInstance, Env, Runtime, RuntimeIndex, describeFunction, getClass } from '@travetto/runtime';
+import { SchemaFieldConfig, SchemaRegistryIndex, ValidationError } from '@travetto/schema';
+
+import { CliCommandShape } from '../types.ts';
+import { CliCommandRegistryIndex } from './registry-index.ts';
+import { CliModuleUtil } from '../module.ts';
+import { CliParseUtil } from '../parse.ts';
+import { CliUtil } from '../util.ts';
+
+type Cmd = CliCommandShape & { env?: string };
+
+type CliCommandConfigOptions = {
+  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<SchemaFieldConfig>;
+  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
+ *
+ * @augments `@travetto/schema:Schema`
+ * @example main
+ * @kind decorator
+ */
+export function CliCommand(cfg: 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]);
+
+    CliCommandRegistryIndex.getForRegister(target).register({
+      runTarget: cfg.runTarget,
+      preMain: async (cmd: Cmd) => {
+        for (const field of VALID_FIELDS) {
+          await field.run(cmd);
+        }
+      }
+    });
+
+    const commandModule = description.module;
+
+    for (const { name, field: { type, ...field } } of VALID_FIELDS) {
+      adapter.registerField(name, field, { type });
+    }
+
+    const runtimeModule = cfg.runtimeModule ?? (cfg.with?.module ? 'current' : undefined);
+
+    if (runtimeModule) { // Validate module
+      adapter.register({
+        validators: [async ({ module: mod }): Promise<ValidationError | undefined> => {
+          const runModule = (runtimeModule === 'command' ? commandModule : mod) || Runtime.main.name;
+
+          // If we need to run as a specific module
+          if (runModule !== Runtime.main.name) {
+            try {
+              RuntimeIndex.reinitForModule(runModule);
+            } catch {
+              return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: '.' };
+            }
+          }
+
+          if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
+            return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: '.' };
+          }
+        }],
+      });
+    }
+  };
+}
+
+/**
+ * Decorator to register a CLI command flag
+ * @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 {
+    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) : [])
+    ];
+    const specifiers = cfg.fileExtensions?.length ? ['file', ...cfg.fileExtensions.map(x => `ext:${x.replace(/[*.]/g, '')}`)] : [];
+
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, { aliases, specifiers });
+  };
+}

package/src/registry/registry-adapter.ts

@@ -0,0 +1,96 @@
+import { Class, classConstruct, describeFunction } from '@travetto/runtime';
+import { RegistryAdapter } from '@travetto/registry';
+import { SchemaRegistryIndex } from '@travetto/schema';
+
+import { CliCommandConfig, CliCommandShape } from '../types.ts';
+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()}`);
+
+export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConfig> {
+  #cls: Class;
+  #config: CliCommandConfig;
+
+  constructor(cls: Class) {
+    this.#cls = cls;
+  }
+
+  finalize(): void {
+    // Add help command
+    const schema = SchemaRegistryIndex.getConfig(this.#cls);
+
+    // Add help to every command
+    (schema.fields ??= {}).help = {
+      type: Boolean,
+      name: 'help',
+      owner: this.#cls,
+      description: 'display help for command',
+      required: { active: false },
+      default: false,
+      access: 'readonly',
+      aliases: ['-h', '--help']
+    };
+
+    const used = new Set(Object.values(schema.fields)
+      .flatMap(f => f.aliases ?? [])
+      .filter(x => !x.startsWith(ENV_PREFIX))
+      .map(stripDashes)
+    );
+
+    for (const field of Object.values(schema.fields)) {
+      const fieldName = field.name.toString();
+      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);
+      const aliases: string[] = field.aliases = [...envAliases];
+
+      if (short === undefined) {
+        short = fieldName.charAt(0);
+        if (!used.has(short)) {
+          aliases.push(`-${short}`);
+          used.add(short);
+        }
+      } else {
+        aliases.push(`-${short}`);
+      }
+
+      aliases.push(`--${long}`);
+
+      if (field.type === Boolean) {
+        aliases.push(`--no-${long}`);
+      }
+    }
+  }
+
+  get(): CliCommandConfig {
+    return this.#config;
+  }
+
+  /**
+   * Registers a cli command
+   */
+  register(...cfg: Partial<CliCommandConfig>[]): CliCommandConfig {
+    const meta = describeFunction(this.#cls);
+    this.#config ??= {
+      cls: this.#cls,
+      preMain: undefined,
+      name: getName(meta.import),
+    };
+    Object.assign(this.#config, ...cfg);
+    return this.#config;
+  }
+
+  /**
+   * Get instance of the command
+   */
+  getInstance(): CliCommandShape {
+    const instance: CliCommandShape = classConstruct(this.#cls);
+    instance._cfg = this.#config;
+    return instance;
+  }
+}

package/src/registry/registry-index.ts

@@ -0,0 +1,124 @@
+import { Class, getClass, getParentClass, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { RegistryAdapter, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
+
+import { CliCommandConfig, CliCommandShape } from '../types.ts';
+import { CliUnknownCommandError } from '../error.ts';
+import { CliCommandRegistryAdapter } from './registry-adapter.ts';
+
+const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
+const getName = (s: string): string => (s.match(CLI_FILE_REGEX)?.groups?.name ?? s).replaceAll('_', ':');
+
+type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
+
+export class CliCommandRegistryIndex implements RegistryIndex {
+
+  static #instance = Registry.registerIndex(this);
+
+  static getForRegister(cls: Class): RegistryAdapter<CliCommandConfig> {
+    return this.#instance.store.getForRegister(cls);
+  }
+
+  static get(cls: Class): CliCommandConfig {
+    return this.#instance.store.get(cls).get();
+  }
+
+  static load(names?: string[]): Promise<CliCommandLoadResult[]> {
+    return this.#instance.load(names);
+  }
+
+  #fileMapping: Map<string, string>;
+  #instanceMapping: Map<string, CliCommandShape> = new Map();
+
+  store = new RegistryIndexStore(CliCommandRegistryAdapter);
+
+  /**
+   * Get list of all commands available
+   */
+  get #commandMapping(): Map<string, string> {
+    if (!this.#fileMapping) {
+      const all = new Map<string, string>();
+      for (const e of RuntimeIndex.find({
+        module: m => !Runtime.production || m.prod,
+        folder: f => f === 'support',
+        file: f => f.role === 'std' && CLI_FILE_REGEX.test(f.sourceFile)
+      })) {
+        all.set(getName(e.sourceFile), e.import);
+      }
+      this.#fileMapping = all;
+    }
+    return this.#fileMapping;
+  }
+
+
+  process(): void {
+    // Do nothing for now?
+  }
+
+  /**
+   * Import command into an instance
+   */
+  async #getInstance(name: string): Promise<CliCommandShape> {
+    if (!this.hasCommand(name)) {
+      throw new CliUnknownCommandError(name);
+    }
+
+    if (this.#instanceMapping.has(name)) {
+      return this.#instanceMapping.get(name)!;
+    }
+
+    const found = this.#commandMapping.get(name)!;
+    const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
+    const filtered = values
+      .filter((v): v is Class => typeof v === 'function')
+      .reduce<Class[]>((acc, v) => {
+        const parent = getParentClass(v);
+        if (parent && !acc.includes(parent)) {
+          acc.push(parent);
+        }
+        acc.push(v);
+        return acc;
+      }, []);
+
+    const uninitialized = filtered
+      .filter(v => !this.store.finalized(v));
+
+
+    // Initialize any uninitialized commands
+    if (uninitialized.length) {
+      // Ensure processed
+      Registry.process(uninitialized.map(v => ({ type: 'added', curr: v })));
+    }
+
+    for (const v of values) {
+      const cfg = this.store.get(v);
+      if (!cfg) {
+        continue;
+      }
+      const result = cfg.getInstance();
+      if (result.isActive !== undefined && !result.isActive()) {
+        continue;
+      }
+      this.#instanceMapping.set(name, result);
+      return result;
+    }
+    throw new CliUnknownCommandError(name);
+  }
+
+  hasCommand(name: string): boolean {
+    return this.#commandMapping.has(name);
+  }
+
+  async load(names?: string[]): Promise<CliCommandLoadResult[]> {
+    const keys = names ?? [...this.#commandMapping.keys()];
+
+    const list = await Promise.all(keys.map(async x => {
+      const instance = await this.#getInstance(x);
+      const config = this.store.get(getClass(instance)).get();
+      const schema = SchemaRegistryIndex.getConfig(getClass(instance));
+      return { command: x, instance, config, schema };
+    }));
+
+    return list.sort((a, b) => a.command.localeCompare(b.command));
+  }
+}

package/src/schema-export.ts

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

package/src/schema.ts

@@ -1,120 +1,27 @@
-import { castKey, castTo, Class } from '@travetto/runtime';
-import { BindUtil, FieldConfig, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
+import { castKey, castTo, getClass } from '@travetto/runtime';
+import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
-import { CliCommandRegistry } from './registry.ts';
-import { ParsedState, CliCommandInput, CliCommandSchema, CliCommandShape } from './types.ts';
+import { ParsedState, CliCommandShape, CliValidationError } from './types.ts';
 import { CliValidationResultError } from './error.ts';
 
-const LONG_FLAG = /^--[a-z][^= ]+/i;
-const SHORT_FLAG = /^-[a-z]/i;
-
-const isBoolFlag = (x?: CliCommandInput): boolean => x?.type === 'boolean' && !x.array;
-
-function baseType(x: FieldConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
-  switch (x.type) {
-    case Date: return { type: 'date' };
-    case Boolean: return { type: 'boolean' };
-    case Number: return { type: 'number' };
-    case RegExp: return { type: 'regex' };
-    case String: {
-      switch (true) {
-        case x.specifiers?.includes('module'): return { type: 'module' };
-        case x.specifiers?.includes('file'): return {
-          type: 'file',
-          fileExtensions: x.specifiers?.map(s => s.split('ext:')[1]).filter(s => !!s)
-        };
-      }
-    }
+const getSource = (source: string | undefined, def: CliValidationError['source']): CliValidationError['source'] => {
+  switch (source) {
+    case 'custom':
+    case 'arg':
+    case 'flag': return source;
+    case undefined: return def;
+    default: return 'custom';
   }
-  return { type: 'string' };
-}
-
-const fieldToInput = (x: FieldConfig): CliCommandInput => ({
-  ...baseType(x),
-  name: x.name,
-  description: x.description,
-  array: x.array,
-  required: x.required?.active,
-  choices: x.enum?.values,
-  default: Array.isArray(x.default) ? x.default.slice(0) : x.default,
-  flagNames: (x.aliases ?? []).slice(0).filter(v => !v.startsWith('env.')),
-  envVars: (x.aliases ?? []).slice(0).filter(v => v.startsWith('env.')).map(v => v.replace('env.', ''))
-});
+};
 
 /**
  * Allows binding describing/binding inputs for commands
  */
 export class CliCommandSchemaUtil {
-
-  /**
-   * Get schema for a given command
-   */
-  static async getSchema(src: Class | CliCommandShape): Promise<CliCommandSchema> {
-    const cls = 'main' in src ? CliCommandRegistry.getClass(src) : src;
-
-    // Ensure finalized
-    const parent = SchemaRegistry.getParentClass(cls);
-    if (parent?.Ⲑid) {
-      SchemaRegistry.onInstall(parent, { type: 'added', curr: parent });
-    }
-    SchemaRegistry.onInstall(cls, { type: 'added', curr: cls });
-
-    const schema = await SchemaRegistry.getViewSchema(cls);
-    const flags = Object.values(schema.schema).map(fieldToInput);
-
-    // Add help command
-    flags.push({ name: 'help', flagNames: ['h'], description: 'display help for command', type: 'boolean' });
-
-    const method = SchemaRegistry.getMethodSchema(cls, 'main').map(fieldToInput);
-
-    const used = new Set(flags
-      .flatMap(f => f.flagNames ?? [])
-      .filter(x => SHORT_FLAG.test(x) || x.replaceAll('-', '').length < 3)
-      .map(x => x.replace(/^-+/, ''))
-    );
-
-    for (const flag of flags) {
-      let short = (flag.flagNames ?? []).find(x => SHORT_FLAG.test(x) || x.replaceAll('-', '').length < 3)?.replace(/^-+/, '');
-      const long = (flag.flagNames ?? []).find(x => LONG_FLAG.test(x) || x.replaceAll('-', '').length > 2)?.replace(/^-+/, '') ??
-        flag.name.replace(/([a-z])([A-Z])/g, (_, l, r: string) => `${l}-${r.toLowerCase()}`);
-      const aliases: string[] = flag.flagNames = [];
-
-      if (short === undefined) {
-        if (!(isBoolFlag(flag) && flag.default === true)) {
-          short = flag.name.charAt(0);
-          if (!used.has(short)) {
-            aliases.push(`-${short}`);
-            used.add(short);
-          }
-        }
-      } else {
-        aliases.push(`-${short}`);
-      }
-
-      aliases.push(`--${long}`);
-
-      if (isBoolFlag(flag)) {
-        aliases.push(`--no-${long}`);
-      }
-    }
-
-    const fullSchema = SchemaRegistry.get(cls);
-    const { cls: _cls, preMain: _preMain, ...meta } = CliCommandRegistry.getByClass(cls)!;
-    const cfg: CliCommandSchema = {
-      ...meta,
-      args: method,
-      flags,
-      title: fullSchema.title ?? cls.name,
-      description: fullSchema.description ?? ''
-    };
-
-    return cfg;
-  }
-
   /**
    * Bind parsed inputs to command
    */
-  static async bindInput<T extends CliCommandShape>(cmd: T, state: ParsedState): Promise<unknown[]> {
+  static bindInput<T extends CliCommandShape>(cmd: T, state: ParsedState): unknown[] {
     const template: Partial<T> = {};
     const bound: unknown[] = [];
 
@@ -140,7 +47,7 @@ export class CliCommandSchemaUtil {
       }
     }
 
-    const cls = CliCommandRegistry.getClass(cmd);
+    const cls = getClass(cmd);
     BindUtil.bindSchemaToObject(cls, cmd, template);
     return BindUtil.coerceMethodParams(cls, 'main', bound);
   }
@@ -149,8 +56,8 @@ export class CliCommandSchemaUtil {
    * Validate command shape with the given arguments
    */
   static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
-    const cls = CliCommandRegistry.getClass(cmd);
-    const paramNames = SchemaRegistry.getMethodSchema(cls, 'main').map(x => x.name);
+    const cls = getClass(cmd);
+    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(x => x.name!);
 
     const validators = [
       (): Promise<void> => SchemaValidator.validate(cls, cmd).then(() => { }),
@@ -169,7 +76,7 @@ export class CliCommandSchemaUtil {
       if (!(err instanceof CliValidationResultError) && !(err instanceof ValidationResultError)) {
         throw err;
       }
-      return err.details.errors.map(v => ({ source: SOURCES[i], ...v }));
+      return err.details.errors.map(v => ({ ...v, source: getSource(v.source, SOURCES[i]) }));
     }));
 
     const errors = (await Promise.all(results)).flatMap(x => (x ?? []));

package/src/types.ts

@@ -6,18 +6,6 @@ type ParsedArg = { type: 'arg', input: string, array?: boolean, index: number };
 type ParsedUnknown = { type: 'unknown', input: string };
 type ParsedInput = ParsedUnknown | ParsedFlag | ParsedArg;
 
-/**
- * Command configuration
- */
-export type CliCommandConfig = {
-  name: string;
-  commandModule: string;
-  runTarget?: boolean;
-  cls: Class<CliCommandShape>;
-  hidden?: boolean;
-  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
-};
-
 export type ParsedState = {
   inputs: string[];
   all: ParsedInput[];
@@ -45,7 +33,6 @@ export interface CliValidationError {
  * @concrete
  */
 export interface CliCommandShape<T extends unknown[] = unknown[]> {
-
   /**
    * Parsed state
    */
@@ -110,31 +97,12 @@ export type CliCommandShapeFields = {
   module?: string;
 };
 
-/**
- * CLI Command argument/flag shape
- */
-export type CliCommandInput<K extends string = string> = {
-  name: string;
-  description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
-  fileExtensions?: string[];
-  choices?: unknown[];
-  required?: boolean;
-  array?: boolean;
-  default?: unknown;
-  flagNames?: K[];
-  envVars?: string[];
-};
-
 /**
  * CLI Command schema shape
  */
-export interface CliCommandSchema<K extends string = string> {
+export interface CliCommandConfig {
+  cls: Class<CliCommandShape>;
   name: string;
-  title: string;
-  commandModule: string;
   runTarget?: boolean;
-  description?: string;
-  args: CliCommandInput[];
-  flags: CliCommandInput<K>[];
-}
+  preMain?: (cmd: CliCommandShape) => void | Promise<void>;
+}