@travetto/cli 8.0.0-alpha.3 → 8.0.0-alpha.31

package/src/registry/decorator.ts

@@ -1,21 +1,14 @@
-import { type Class, type ClassInstance, Env, Runtime, RuntimeIndex, castTo, describeFunction, getClass } from '@travetto/runtime';
+import { type Class, type ClassInstance, castTo, describeFunction, Env, getClass, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { SchemaRegistryIndex, type ValidationError } from '@travetto/schema';
 
-import type { CliCommandShape } from '../types.ts';
-import { CliCommandRegistryIndex } from './registry-index.ts';
 import { CliModuleUtil } from '../module.ts';
 import { CliParseUtil } from '../parse.ts';
+import type { CliCommandShape } from '../types.ts';
 import { CliUtil } from '../util.ts';
+import { CliCommandRegistryIndex } from './registry-index.ts';
 
 type CliCommandConfigOptions = { runTarget?: boolean };
-type CliFlagOptions = { full?: string, short?: string, envVars?: string[] };
-
-function runBeforeMain<T>(cls: Class, handler: (item: T) => (unknown | Promise<unknown>), runTarget?: boolean): void {
-  CliCommandRegistryIndex.getForRegister(cls).register({
-    runTarget,
-    preMain: [async (cmd): Promise<void> => { await handler(castTo(cmd)); }]
-  });
-}
+type CliFlagOptions = { full?: string; short?: string; envVars?: string[] };
 
 /**
  * Decorator to register a CLI command
@@ -39,8 +32,7 @@ export function CliCommand(config: CliCommandConfigOptions = {}) {
  */
 export function CliFlag(config: CliFlagOptions) {
   return function (instance: ClassInstance, property: string): void {
-    SchemaRegistryIndex.getForRegister(getClass(instance))
-      .registerField(property, CliParseUtil.buildAliases(config));
+    SchemaRegistryIndex.getForRegister(getClass(instance)).registerField(property, CliParseUtil.buildAliases(config));
   };
 }
 
@@ -72,11 +64,9 @@ export function CliProfilesFlag(config: CliFlagOptions = {}) {
       description: 'Application profiles'
     });
 
-    runBeforeMain(cls, (cmd: typeof instance) =>
-      Env.TRV_PROFILES.set([...cmd[property] ?? [], ...(Env.TRV_PROFILES.list ?? [])])
-    );
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 1, cmd => Env.TRV_PROFILES.add(...(cmd[property] ?? [])));
   };
-};
+}
 
 /**
  * Registers a flag to support targeting a specific module
@@ -93,28 +83,40 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
       ...CliParseUtil.buildAliases(config, Env.TRV_MODULE.key),
       description: 'Module to run for',
       specifiers: ['module'],
-      required: { active: Runtime.monoRoot },
+      required: { active: Runtime.monoRoot && config.scope !== 'command' }
     });
 
     SchemaRegistryIndex.getForRegister(cls).register({
-      validators: [async (cmd: CliCommandShape): Promise<ValidationError | undefined> => {
-        const typed: (typeof cmd) & { [property]?: string } = castTo(cmd);
-        const providedModule = typed[property];
-        const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
-
-        // If we need to run as a specific module
-        if (runModule !== Runtime.main.name) {
-          try {
-            RuntimeIndex.reinitForModule(runModule);
-          } catch {
+      validators: [
+        async (cmd: CliCommandShape): Promise<ValidationError | undefined> => {
+          const typed: typeof cmd & { [property]?: string } = castTo(cmd);
+          const providedModule = typed[property];
+          const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
+
+          // If we need to run as a specific module
+          if (runModule !== Runtime.main.name && RuntimeIndex.getModule(runModule) === undefined) {
             return { source: 'flag', message: `${runModule} is an unknown module`, kind: 'custom', path: property };
           }
-        }
 
-        if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
-          return { source: 'flag', message: `${runModule} does not have ${commandModule} as a dependency`, kind: 'custom', path: property };
+          if (!(await CliModuleUtil.moduleHasDependency(runModule, commandModule))) {
+            return {
+              source: 'flag',
+              message: `${runModule} does not have ${commandModule} as a dependency`,
+              kind: 'custom',
+              path: property
+            };
+          }
         }
-      }],
+      ]
+    });
+
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 5, cmd => {
+      const typed: typeof cmd & { [property]?: string } = castTo(cmd);
+      const providedModule = typed[property];
+      const runModule = (config.scope === 'command' ? commandModule : providedModule) || Runtime.main.name;
+      if (runModule !== Runtime.main.name) {
+        RuntimeIndex.reinitForModule(runModule);
+      }
     });
   };
 }
@@ -127,14 +129,17 @@ export function CliModuleFlag(config: CliFlagOptions & { scope?: 'current' | 'co
 export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
     const cls = getClass(instance);
+    if (Runtime.production) {
+      return;
+    }
+
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
       ...CliParseUtil.buildAliases(config),
-      description: 'Should the invocation automatically restart on source changes',
-      default: Runtime.localDevelopment,
-      required: { active: false },
+      description: 'Should the invocation automatically restart on source changes'
     });
 
-    runBeforeMain(cls, (cmd: typeof instance) => CliUtil.runWithRestartOnChange(cmd[property]), true);
+    CliCommandRegistryIndex.getForRegister(cls).register({ runTarget: true });
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 20, cmd => CliUtil.runWithRestartOnChange(cmd[property]));
   };
 }
 
@@ -145,20 +150,20 @@ export function CliRestartOnChangeFlag(config: CliFlagOptions = {}) {
  */
 export function CliDebugIpcFlag(config: CliFlagOptions = {}) {
   return function <K extends string, T extends Partial<Record<K, boolean>>>(instance: T, property: K): void {
+    if (Runtime.production) {
+      return;
+    }
+
     const cls = getClass(instance);
     SchemaRegistryIndex.getForRegister(cls).registerField(property, {
       ...CliParseUtil.buildAliases(config, Env.TRV_DEBUG_IPC.key),
-      description: 'Should the invocation automatically restart on source changes',
-      default: Runtime.localDevelopment,
-      required: { active: false },
+      description: 'Should the invocation support debugging via IPC (e.g. from VSCode)'
     });
 
-    runBeforeMain(cls,
-      (cmd: typeof instance & CliCommandShape) => {
-        const cliConfig = CliCommandRegistryIndex.get(cls);
-        return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
-      },
-      true
-    );
+    CliCommandRegistryIndex.getForRegister(cls).register({ runTarget: true });
+    CliCommandRegistryIndex.registerPreMain<typeof instance>(cls, 10, cmd => {
+      const cliConfig = CliCommandRegistryIndex.get(cls);
+      return cmd[property] && CliUtil.runWithDebugIpc(cliConfig.name);
+    });
   };
-}
+}

package/src/registry/registry-adapter.ts

@@ -1,21 +1,22 @@
-import { type Class, classConstruct, describeFunction } from '@travetto/runtime';
 import type { RegistryAdapter } from '@travetto/registry';
+import { type Class, classConstruct, describeFunction } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import type { CliCommandConfig, CliCommandShape } from '../types.ts';
 import { CliParseUtil, ENV_PREFIX } from '../parse.ts';
+import type { CliCommandConfig, CliCommandShape } from '../types.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
 
 const getName = (name: string): string => (name.match(CLI_FILE_REGEX)?.groups?.name ?? name).replaceAll('_', ':');
 const stripDashes = (flag?: string): string | undefined => flag?.replace(/^-+/, '');
-const toFlagName = (field: string): string => field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
+const toFlagName = (field: string): string =>
+  field.replace(/([a-z])([A-Z])/g, (_, left: string, right: string) => `${left}-${right.toLowerCase()}`);
 
 function combineClasses(base: CliCommandConfig, ...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
   for (const config of configs) {
     base.runTarget = config.runTarget ?? base.runTarget;
     if (config.preMain) {
-      base.preMain = [...base.preMain ?? [], ...config.preMain ?? []];
+      base.preMain = [...(base.preMain ?? []), ...(config.preMain ?? [])];
     }
   }
   return base;
@@ -29,26 +30,15 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
     this.#cls = cls;
   }
 
-  finalize(): void {
+  // TODO: handle when aliases overlap/conflict
+  finalize(parent?: CliCommandConfig): void {
     // Add help command
     const schema = SchemaRegistryIndex.getConfig(this.#cls);
-
-    // Add help to every command
-    (schema.fields ??= {}).help = {
-      type: Boolean,
-      name: 'help',
-      class: 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(field => field.aliases ?? [])
-      .filter(alias => !alias.startsWith(ENV_PREFIX))
-      .map(stripDashes)
+    const used = new Set(
+      Object.values(schema.fields)
+        .flatMap(field => field.aliases ?? [])
+        .filter(alias => !alias.startsWith(ENV_PREFIX))
+        .map(stripDashes)
     );
 
     for (const field of Object.values(schema.fields)) {
@@ -57,7 +47,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
 
       let short = stripDashes(shortAliases?.[0]) ?? rawAliases.find(alias => alias.length <= 2);
       const long = stripDashes(longAliases?.[0]) ?? rawAliases.find(alias => alias.length >= 3) ?? toFlagName(fieldName);
-      const aliases: string[] = field.aliases = [...envAliases];
+      const aliases: string[] = (field.aliases = [...envAliases]);
 
       if (short === undefined) {
         short = fieldName.charAt(0);
@@ -75,6 +65,13 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
         aliases.push(`--no-${long}`);
       }
     }
+
+    if (parent) {
+      this.#config.preMain = [...this.#config.preMain, ...(parent?.preMain ?? [])];
+    }
+
+    // Sort
+    this.#config.preMain = this.#config.preMain.toSorted((left, right) => left.priority - right.priority);
   }
 
   get(): CliCommandConfig {
@@ -86,7 +83,7 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
    */
   register(...configs: Partial<CliCommandConfig>[]): CliCommandConfig {
     const metadata = describeFunction(this.#cls);
-    this.#config ??= { cls: this.#cls, name: getName(metadata.import), preMain: [], runTarget: true };
+    this.#config ??= { cls: this.#cls, name: getName(metadata.import), preMain: [], runTarget: false };
     return combineClasses(this.#config, ...configs);
   }
 
@@ -96,4 +93,4 @@ export class CliCommandRegistryAdapter implements RegistryAdapter<CliCommandConf
   getInstance(): CliCommandShape {
     return classConstruct(this.#cls);
   }
-}
+}

package/src/registry/registry-index.ts

@@ -1,19 +1,18 @@
-import { type Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
-import { type RegistryAdapter, type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { Registry, type RegistryAdapter, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Any, type Class, getClass, getParentClass, isClass, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { type SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
-import type { CliCommandConfig, CliCommandShape } from '../types.ts';
+import type { CliCommandConfig, CliCommandShape, PreMainHandler } from '../types.ts';
 import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
 const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?.name ?? field).replaceAll('_', ':');
 
-type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
+type CliCommandLoadResult = { command: string; config: CliCommandConfig; instance: CliCommandShape; schema: SchemaClassConfig };
 
 export const UNKNOWN_COMMAND = Symbol();
 
 export class CliCommandRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(this);
 
   static getForRegister(cls: Class): RegistryAdapter<CliCommandConfig> {
@@ -28,12 +27,18 @@ export class CliCommandRegistryIndex implements RegistryIndex {
     return this.#instance.load(names);
   }
 
+  static registerPreMain<T = Any>(cls: Class, priority: number, handler: PreMainHandler<T>['handler']): void {
+    CliCommandRegistryIndex.getForRegister(cls).register({ preMain: [{ handler, priority }] });
+  }
+
   #fileMapping: Map<string, string>;
   #instanceMapping: Map<string, CliCommandShape> = new Map();
 
   store = new RegistryIndexStore(CliCommandRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   /**
    * Get list of all commands available
@@ -67,19 +72,16 @@ export class CliCommandRegistryIndex implements RegistryIndex {
 
     const found = this.#commandMapping.get(name)!;
     const values = Object.values(await Runtime.importFrom<Record<string, Class>>(found));
-    const filtered = values
-      .filter(isClass)
-      .reduce<Class[]>((classes, cls) => {
-        const parent = getParentClass(cls);
-        if (parent && !classes.includes(parent)) {
-          classes.push(parent);
-        }
-        classes.push(cls);
-        return classes;
-      }, []);
-
-    const uninitialized = filtered
-      .filter(cls => !this.store.finalized(cls));
+    const filtered = values.filter(isClass).reduce<Class[]>((classes, cls) => {
+      const parent = getParentClass(cls);
+      if (parent && !classes.includes(parent)) {
+        classes.push(parent);
+      }
+      classes.push(cls);
+      return classes;
+    }, []);
+
+    const uninitialized = filtered.filter(cls => !this.store.finalized(cls));
 
     // Initialize any uninitialized commands
     if (uninitialized.length) {
@@ -106,13 +108,15 @@ export class CliCommandRegistryIndex implements RegistryIndex {
   async load(names?: string[]): Promise<CliCommandLoadResult[]> {
     const keys = names ?? [...this.#commandMapping.keys()];
 
-    const list = await Promise.all(keys.map(async key => {
-      const instance = await this.#getInstance(key);
-      const config = this.store.get(getClass(instance)).get();
-      const schema = SchemaRegistryIndex.getConfig(getClass(instance));
-      return { command: key, instance, config, schema };
-    }));
+    const list = await Promise.all(
+      keys.map(async key => {
+        const instance = await this.#getInstance(key);
+        const config = this.store.get(getClass(instance)).get();
+        const schema = SchemaRegistryIndex.getConfig(getClass(instance));
+        return { command: key, instance, config, schema };
+      })
+    );
 
     return list.sort((a, b) => a.command.localeCompare(b.command));
   }
-}
+}

package/src/schema-export.ts

@@ -1,7 +1,7 @@
-import { castTo, type Class, describeFunction } from '@travetto/runtime';
+import { type Class, castTo, describeFunction } from '@travetto/runtime';
 import { type SchemaInputConfig, SchemaRegistryIndex } from '@travetto/schema';
 
-import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
+import { CliCommandRegistryIndex } from './registry/registry-index.ts';
 
 /**
  * CLI Command argument/flag shape
@@ -32,24 +32,30 @@ export interface CliCommandSchema<K extends string = string> {
 }
 
 export class CliSchemaExportUtil {
-
   /**
    * Get the base type for a CLI command input
    */
   static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
     switch (castTo<Function>(config.type)) {
-      case Date: return { type: 'date' };
-      case Boolean: return { type: 'boolean' };
-      case Number: return { type: 'number' };
-      case RegExp: return { type: 'regex' };
-      case BigInt: return { type: 'bigint' };
+      case Date:
+        return { type: 'date' };
+      case Boolean:
+        return { type: 'boolean' };
+      case Number:
+        return { type: 'number' };
+      case RegExp:
+        return { type: 'regex' };
+      case BigInt:
+        return { type: 'bigint' };
       case String: {
         switch (true) {
-          case config.specifiers?.includes('module'): return { type: 'module' };
-          case config.specifiers?.includes('file'): return {
-            type: 'file',
-            fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
-          };
+          case config.specifiers?.includes('module'):
+            return { type: 'module' };
+          case config.specifiers?.includes('file'):
+            return {
+              type: 'file',
+              fileExtensions: config.specifiers?.map(specifier => specifier.split('ext:')[1]).filter(specifier => !!specifier)
+            };
         }
       }
     }
@@ -62,14 +68,17 @@ export class CliSchemaExportUtil {
   static processInput(config: SchemaInputConfig): CliCommandInput {
     return {
       ...this.baseInputType(config),
-      ...(('name' in config && typeof config.name === 'string') ? { name: config.name } : { name: '' }),
+      ...('name' in config && typeof config.name === 'string' ? { name: config.name } : { name: '' }),
       description: config.description,
       array: config.array,
       required: config.required?.active !== false,
       choices: config.enum?.values,
       default: Array.isArray(config.default) ? config.default.slice(0) : config.default,
       flagNames: (config.aliases ?? []).slice(0).filter(value => !value.startsWith('env.')),
-      envVars: (config.aliases ?? []).slice(0).filter(value => value.startsWith('env.')).map(value => value.replace('env.', ''))
+      envVars: (config.aliases ?? [])
+        .slice(0)
+        .filter(value => value.startsWith('env.'))
+        .map(value => value.replace('env.', ''))
     };
   }
 
@@ -87,4 +96,4 @@ export class CliSchemaExportUtil {
       runTarget: config.runTarget ?? false
     };
   }
-}
+}

package/src/schema.ts

@@ -1,15 +1,18 @@
 import { castKey, castTo, getClass } from '@travetto/runtime';
-import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError, type ValidationError } from '@travetto/schema';
+import { BindUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
-import type { ParsedState, CliCommandShape } from './types.ts';
+import type { CliCommandShape, ParsedState } from './types.ts';
 
 const getSource = (source: string | undefined, defaultSource: ValidationError['source']): ValidationError['source'] => {
   switch (source) {
     case 'custom':
     case 'arg':
-    case 'flag': return source;
-    case undefined: return defaultSource;
-    default: return 'custom';
+    case 'flag':
+      return source;
+    case undefined:
+      return defaultSource;
+    default:
+      return 'custom';
   }
 };
 
@@ -41,7 +44,7 @@ export class CliCommandSchemaUtil {
           const key = castKey<T>(item.fieldName);
           const value = item.value!;
           if (item.array) {
-            castTo<unknown[]>(template[key] ??= castTo([])).push(value);
+            castTo<unknown[]>((template[key] ??= castTo([]))).push(value);
           } else {
             template[key] = castTo(value);
           }
@@ -49,7 +52,7 @@ export class CliCommandSchemaUtil {
         }
         case 'arg': {
           if (item.array) {
-            castTo<unknown[]>(bound[item.index] ??= []).push(item.input);
+            castTo<unknown[]>((bound[item.index] ??= [])).push(item.input);
           } else {
             bound[item.index] = item.input;
           }
@@ -67,11 +70,13 @@ export class CliCommandSchemaUtil {
    */
   static async validate(command: CliCommandShape, args: unknown[]): Promise<typeof command> {
     const cls = getClass(command);
-    const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
+    const paramNames = SchemaRegistryIndex.get(cls)
+      .getMethod('main')
+      .parameters.map(config => config.name!);
 
     const results = await Promise.all([
       SchemaValidator.validate(cls, command).then(() => [], transformFlagErrors),
-      SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors),
+      SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors)
     ]);
 
     const errors = results.flat();
@@ -80,4 +85,4 @@ export class CliCommandSchemaUtil {
     }
     return command;
   }
-}
+}

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 { RuntimeError, ExecUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
 import type { IndexedModule } from '@travetto/manifest';
+import { ExecUtil, Runtime, RuntimeError, RuntimeIndex } from '@travetto/runtime';
 
 export class CliScmUtil {
   /**
@@ -12,17 +12,20 @@ export class CliScmUtil {
    * @returns
    */
   static isRepoRoot(folder: string): Promise<boolean> {
-    return fs.stat(path.resolve(folder, '.git')).then(() => true, () => false);
+    return fs.stat(path.resolve(folder, '.git')).then(
+      () => true,
+      () => false
+    );
   }
 
   /**
    * Get author information
    * @returns
    */
-  static async getAuthor(): Promise<{ name?: string, email: string }> {
+  static async getAuthor(): Promise<{ name?: string; email: string }> {
     const [name, email] = await Promise.all([
       ExecUtil.getResult(spawn('git', ['config', 'user.name']), { catch: true }),
-      ExecUtil.getResult(spawn('git', ['config', 'user.email'])),
+      ExecUtil.getResult(spawn('git', ['config', 'user.email']))
     ]);
     return {
       name: (name.valid ? name.stdout.trim() : '') || process.env.USER,
@@ -38,7 +41,8 @@ export class CliScmUtil {
     const result = await ExecUtil.getResult(spawn('git', ['log', '--pretty=oneline'], { cwd: Runtime.workspace.path }));
     return result.stdout
       .split(/\n/)
-      .find(line => /Publish /.test(line))?.split(/\s+/)?.[0];
+      .find(line => /Publish /.test(line))
+      ?.split(/\s+/)?.[0];
   }
 
   /**
@@ -48,9 +52,15 @@ export class CliScmUtil {
    */
   static async findChangedFiles(fromHash: string, toHash: string = 'HEAD'): Promise<string[]> {
     const rootPath = Runtime.workspace.path;
-    const result = await ExecUtil.getResult(spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: rootPath }), { catch: true });
+    const result = await ExecUtil.getResult(
+      spawn('git', ['diff', '--name-only', `${fromHash}..${toHash}`, ':!**/DOC.*', ':!**/README.*'], { cwd: rootPath }),
+      { catch: true }
+    );
     if (!result.valid) {
-      throw new RuntimeError('Unable to detect changes between', { category: 'data', details: { fromHash, toHash, output: (result.stderr || result.stdout) } });
+      throw new RuntimeError('Unable to detect changes between', {
+        category: 'data',
+        details: { fromHash, toHash, output: result.stderr || result.stdout }
+      });
     }
     const out = new Set<string>();
     for (const line of result.stdout.split(/\n/g)) {
@@ -76,8 +86,7 @@ export class CliScmUtil {
       .map(file => RuntimeIndex.getModule(file.module))
       .filter(module => !!module);
 
-    return [...new Set(modules)]
-      .toSorted((a, b) => a.name.localeCompare(b.name));
+    return [...new Set(modules)].toSorted((a, b) => a.name.localeCompare(b.name));
   }
 
   /**
@@ -103,4 +112,4 @@ export class CliScmUtil {
     const res2 = await ExecUtil.getResult(spawn('git', ['diff', '--quiet', '--exit-code', '--cached']), { catch: true });
     return !res1.valid || !res2.valid;
   }
-}
+}