@c9up/ream 0.1.25 → 0.1.27

package/dist/console/BaseCommand.d.ts

@@ -0,0 +1,217 @@
+/**
+ * BaseCommand — the class application commands extend (Console parity).
+ *
+ * Everything the kernel needs sits on the STATIC side (`commandName`,
+ * `description`, `options`, and the `args` / `flags` metadata written by the
+ * decorators), so extending this class is a convenience, not a requirement:
+ * it supplies `this.logger`, `this.prompt`, `this.app` and the `exitCode`
+ * contract. Packages that must not depend on `@c9up/ream` declare the same
+ * statics on a plain class instead.
+ *
+ *   export default class Provision extends BaseCommand {
+ *     static commandName = 'provision'
+ *     static description = 'Create the owner account'
+ *     static options: CommandOptions = { startApp: true }
+ *
+ *     @flags.string({ description: 'Owner email', required: true })
+ *     declare email: string
+ *
+ *     async run() {
+ *       const users = await this.app.container.resolve('users')
+ *       await users.createOwner(this.email)
+ *       this.logger.success(`Owner created: ${this.email}`)
+ *     }
+ *   }
+ */
+import type { Application } from '../Application.js';
+import type { Colors, Logger, Ui } from './cliui.js';
+import type { Kernel } from './Kernel.js';
+import type { Prompt } from './prompts.js';
+import type { ArgumentMetaData, ArgumentsParserOptions, CommandOptions, CommandSnapshot, FlagMetaData, FlagsParserOptions, ParsedInput, SerializedCommand } from './types.js';
+export declare abstract class BaseCommand {
+    /** Name typed on the command line, e.g. `provision` or `make:controller`. */
+    static commandName: string;
+    /** One-line summary shown by `list`. */
+    static description: string;
+    /**
+     * Alternative names this command answers to (Console `static aliases`). Unlike
+     * `commandsAliases` in the rc file, these travel with the command itself.
+     */
+    static aliases: readonly string[];
+    /** Longer text shown under the usage line by `<command> --help`. */
+    static help?: string | string[];
+    static options: CommandOptions;
+    /**
+     * Written by the `@args` / `@flags` decorators. Declared here so a subclass
+     * that uses neither still satisfies the dispatch contract, and so the
+     * decorators have an inherited list to copy from.
+     */
+    static args: readonly ArgumentMetaData[];
+    static flags: readonly FlagMetaData[];
+    /**
+     * Assigned by the kernel before `run()`. Declared with `declare` so no class
+     * field is emitted — under `target: ES2022` a real field would be
+     * re-initialised to `undefined` at construction and wipe the assignment.
+     */
+    logger: Logger;
+    /** Tables, stickers, instructions, tasks — and the raw-mode switch. */
+    ui: Ui;
+    /** Chainable ANSI helpers: `this.colors.green('DONE')`. */
+    colors: Colors;
+    prompt: Prompt;
+    /**
+     * The booted application. Only meaningful when the command sets
+     * `options.startApp` — otherwise the kernel never boots, and reading this is
+     * a programming error the kernel reports rather than a silent `undefined`.
+     */
+    app: Application;
+    /**
+     * The kernel that dispatched this command (Console parity).
+     *
+     * Assigned for every command, booted app or not: it is the registry, and a
+     * command that inspects or lists its siblings — `list` is the built-in
+     * example — has nowhere else to read them from.
+     */
+    kernel: Kernel;
+    /**
+     * Every parsed input, as Console exposes it: `this.parsed.args` /
+     * `this.parsed.flags`. The declared ones are also assigned to their
+     * properties; this is the whole picture, including flags accepted through
+     * `allowUnknownFlags`.
+     */
+    parsed: ParsedInput;
+    /** Set it to make the process exit non-zero without throwing. */
+    exitCode?: number;
+    /** What `run()` returned — filled by the kernel (Console `command.result`). */
+    result?: unknown;
+    /**
+     * The error thrown by `prepare` / `interact` / `run`, assigned before
+     * `completed()` runs so the hook can inspect it (Console parity).
+     */
+    error?: unknown;
+    /** Assigned by the kernel — see {@link terminate}. */
+    protected onTerminate?: () => void | Promise<void>;
+    /**
+     * Lifecycle hooks, run in this order around `run()`: `prepare`, `interact`,
+     * `run`, then `completed` — which runs even when one of the earlier stages
+     * threw. Returning `true` from `completed()` marks the error handled, so the
+     * kernel stops propagating it.
+     */
+    prepare?(...args: never[]): void | Promise<void>;
+    interact?(...args: never[]): void | Promise<void>;
+    completed?(...args: never[]): boolean | void | Promise<boolean | void>;
+    /**
+     * Shut down a `staysAlive` command. Without it a long-running command has no
+     * way to hand control back — the kernel deliberately does not tear the app
+     * down for those.
+     */
+    terminate(): Promise<void>;
+    /** Has {@link boot} run for THIS class — not for one of its ancestors. */
+    static booted: boolean;
+    /**
+     * Give this class its OWN copy of the inherited static declarations
+     * (Console `boot`).
+     *
+     * Without it, `Child.args.push(...)` would append to the array the parent
+     * declared, and every command in the hierarchy would share one list. Called
+     * by everything that reads or writes those statics, so it is normally
+     * invisible; it is public because ported Console code calls it directly.
+     */
+    static boot(): void;
+    /**
+     * Declare an argument without a decorator (Console `defineArgument`).
+     *
+     * The decorators are the ergonomic form, but a command built at runtime — or
+     * one in a package that must not import the framework — needs a plain call.
+     */
+    static defineArgument(name: string, options?: Partial<ArgumentMetaData>): void;
+    /** Declare a flag without a decorator (Console `defineFlag`). */
+    static defineFlag(name: string, options?: Partial<FlagMetaData>): void;
+    /**
+     * The command's metadata as plain data (Console `serialize`).
+     *
+     * What `ream list --json` and any tooling reads, without having to know how
+     * the decorators stored it.
+     */
+    static serialize(): SerializedCommand;
+    /**
+     * How this command's inputs are parsed, grouped by type (Console
+     * `getParserOptions`).
+     *
+     * Ream's parser reads the declarations directly, so nothing internal calls
+     * this; it exists because Console code inspects the shape — and it is derived
+     * from the same metadata, so it cannot describe something the parser would
+     * not do.
+     */
+    static getParserOptions(options?: Partial<FlagsParserOptions>): {
+        flagsParserOptions: FlagsParserOptions;
+        argumentsParserOptions: ArgumentsParserOptions[];
+    };
+    /**
+     * Check a parsed input against this command's declarations (Console `validate`).
+     *
+     * The parser enforces the same rules while parsing, so calling this on its
+     * output always passes. It is here for the case Console documents: an input built
+     * by hand, which has never been through a parser.
+     *
+     * Positional values are accepted as a list (Console's shape) or keyed by property
+     * name (what `this.parsed.args` holds), so the same call works from both.
+     */
+    static validate(parsed: {
+        args: readonly unknown[] | Record<string, unknown>;
+        flags?: Record<string, unknown>;
+        unknownFlags?: readonly string[];
+    }): void;
+    /**
+     * Assign the parsed values to their properties (Console `hydrate`).
+     *
+     * Idempotent: the kernel calls it before `run()`, and a ported command may
+     * call it again without the values being recomputed.
+     */
+    hydrate(): void;
+    /** Set once {@link hydrate} has run. */
+    protected hydrated: boolean;
+    /**
+     * Hydrate, then run — Console's instance-level `exec()`.
+     *
+     * Deliberately NOT the kernel's `exec()`: this one runs `run()` alone and
+     * rethrows, while the kernel drives the whole lifecycle (`prepare`,
+     * `interact`, `completed`) and reports the failure on the command instead.
+     */
+    exec(): Promise<unknown>;
+    /** The statics, readable from the instance (Console parity). */
+    get commandName(): string;
+    get options(): CommandOptions;
+    get args(): readonly ArgumentMetaData[];
+    get flags(): readonly FlagMetaData[];
+    /**
+     * A snapshot of THIS execution (Console `toJSON`): what the command received and
+     * what it produced.
+     *
+     * Distinct from the static {@link serialize}, which describes the command's
+     * contract. Returning the metadata here would drop `exitCode`, `result` and
+     * `error` — exactly what a test or an integration reads after running it.
+     */
+    toJSON(): CommandSnapshot;
+    /**
+     * Was this command the one invoked on the command line, rather than one
+     * another command called through `consoleApp.exec()`? Assigned by the kernel.
+     */
+    isMain: boolean;
+    abstract run(...args: never[]): unknown;
+    /** The command finished with exit code 0. */
+    assertSucceeded(): void;
+    /** The command finished with a non-zero exit code. */
+    assertFailed(): void;
+    assertExitCode(expected: number): void;
+    assertNotExitCode(unexpected: number): void;
+    /**
+     * A line equal to `message` was logged. Pass a stream to require it went
+     * there — a warning belongs on stderr, and asserting that is the point.
+     */
+    assertLog(message: string, stream?: 'stdout' | 'stderr'): void;
+    assertLogMatches(pattern: RegExp, stream?: 'stdout' | 'stderr'): void;
+    /** Every expected row was rendered — the header counts as one (Console). */
+    assertTableRows(expected: readonly (readonly string[])[]): void;
+}
+//# sourceMappingURL=BaseCommand.d.ts.map

package/dist/console/BaseCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCommand.d.ts","sourceRoot":"","sources":["../../src/console/BaseCommand.ts"],"names":[],"mappings":"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"}

package/dist/console/BaseCommand.js

@@ -0,0 +1,340 @@
+/**
+ * BaseCommand — the class application commands extend (Console parity).
+ *
+ * Everything the kernel needs sits on the STATIC side (`commandName`,
+ * `description`, `options`, and the `args` / `flags` metadata written by the
+ * decorators), so extending this class is a convenience, not a requirement:
+ * it supplies `this.logger`, `this.prompt`, `this.app` and the `exitCode`
+ * contract. Packages that must not depend on `@c9up/ream` declare the same
+ * statics on a plain class instead.
+ *
+ *   export default class Provision extends BaseCommand {
+ *     static commandName = 'provision'
+ *     static description = 'Create the owner account'
+ *     static options: CommandOptions = { startApp: true }
+ *
+ *     @flags.string({ description: 'Owner email', required: true })
+ *     declare email: string
+ *
+ *     async run() {
+ *       const users = await this.app.container.resolve('users')
+ *       await users.createOwner(this.email)
+ *       this.logger.success(`Owner created: ${this.email}`)
+ *     }
+ *   }
+ */
+import { createAssertions } from './assertions.js';
+import { assertArgumentOrder, buildArgument, buildFlag } from './decorators.js';
+import { assignParsedValues, validateParsed } from './parser.js';
+export class BaseCommand {
+    /** Name typed on the command line, e.g. `provision` or `make:controller`. */
+    static commandName = '';
+    /** One-line summary shown by `list`. */
+    static description = '';
+    /**
+     * Alternative names this command answers to (Console `static aliases`). Unlike
+     * `commandsAliases` in the rc file, these travel with the command itself.
+     */
+    static aliases = [];
+    /** Longer text shown under the usage line by `<command> --help`. */
+    static help;
+    static options = {};
+    /**
+     * Written by the `@args` / `@flags` decorators. Declared here so a subclass
+     * that uses neither still satisfies the dispatch contract, and so the
+     * decorators have an inherited list to copy from.
+     */
+    static args = [];
+    static flags = [];
+    /** Set it to make the process exit non-zero without throwing. */
+    exitCode;
+    /** What `run()` returned — filled by the kernel (Console `command.result`). */
+    result;
+    /**
+     * The error thrown by `prepare` / `interact` / `run`, assigned before
+     * `completed()` runs so the hook can inspect it (Console parity).
+     */
+    error;
+    /**
+     * Shut down a `staysAlive` command. Without it a long-running command has no
+     * way to hand control back — the kernel deliberately does not tear the app
+     * down for those.
+     */
+    async terminate() {
+        await this.onTerminate?.();
+    }
+    /** Has {@link boot} run for THIS class — not for one of its ancestors. */
+    static booted = false;
+    /**
+     * Give this class its OWN copy of the inherited static declarations
+     * (Console `boot`).
+     *
+     * Without it, `Child.args.push(...)` would append to the array the parent
+     * declared, and every command in the hierarchy would share one list. Called
+     * by everything that reads or writes those statics, so it is normally
+     * invisible; it is public because ported Console code calls it directly.
+     */
+    static boot() {
+        if (Object.hasOwn(this, 'booted') && this.booted === true)
+            return;
+        this.booted = true;
+        // Only the mutable declarations are copied. Console also re-assigns the scalar
+        // statics (name, description, help); for a string, an own copy and an
+        // inherited one are indistinguishable — the line would read as a bug.
+        this.args = [...this.args];
+        this.flags = [...this.flags];
+        this.aliases = [...this.aliases];
+        this.options = { staysAlive: false, allowUnknownFlags: false, ...this.options };
+    }
+    /**
+     * Declare an argument without a decorator (Console `defineArgument`).
+     *
+     * The decorators are the ergonomic form, but a command built at runtime — or
+     * one in a package that must not import the framework — needs a plain call.
+     */
+    static defineArgument(name, options = {}) {
+        this.boot();
+        const list = [...this.args];
+        // Built by the same function the decorators use: a field added on one path
+        // and forgotten on the other is a silent divergence, not a compile error.
+        const argument = buildArgument(name, options);
+        // Console's two ordering rules, shared with the decorators — see
+        // `assertArgumentOrder`. They are not pedantry: a spread argument eats the
+        // tail, so nothing after it can ever be filled, and a required argument
+        // behind an optional one can only be reached by passing the optional one,
+        // which makes "required" a lie.
+        assertArgumentOrder(list, argument);
+        list.push(argument);
+        this.args = list;
+    }
+    /** Declare a flag without a decorator (Console `defineFlag`). */
+    static defineFlag(name, options = {}) {
+        this.boot();
+        const list = [...this.flags];
+        list.push(buildFlag(name, options));
+        this.flags = list;
+    }
+    /**
+     * The command's metadata as plain data (Console `serialize`).
+     *
+     * What `ream list --json` and any tooling reads, without having to know how
+     * the decorators stored it.
+     */
+    static serialize() {
+        this.boot();
+        // `parse` is a function: keeping it would make this object look JSON-safe
+        // while quietly losing a field the moment it is stringified.
+        const withoutParse = (entry) => {
+            const { parse: _dropped, ...rest } = entry;
+            return rest;
+        };
+        const colon = this.commandName.indexOf(':');
+        return {
+            commandName: this.commandName,
+            namespace: colon === -1 ? null : this.commandName.slice(0, colon),
+            description: this.description,
+            help: this.help,
+            aliases: [...this.aliases],
+            options: { ...this.options },
+            args: this.args.map(withoutParse),
+            flags: this.flags.map(withoutParse),
+        };
+    }
+    /**
+     * How this command's inputs are parsed, grouped by type (Console
+     * `getParserOptions`).
+     *
+     * Ream's parser reads the declarations directly, so nothing internal calls
+     * this; it exists because Console code inspects the shape — and it is derived
+     * from the same metadata, so it cannot describe something the parser would
+     * not do.
+     */
+    static getParserOptions(options) {
+        this.boot();
+        const flagsParserOptions = {
+            all: [],
+            string: [],
+            boolean: [],
+            number: [],
+            array: [],
+            alias: {},
+            count: [],
+            coerce: {},
+            default: {},
+            ...options,
+        };
+        for (const flag of this.flags) {
+            flagsParserOptions.all.push(flag.flagName);
+            if (flag.alias.length > 0)
+                flagsParserOptions.alias[flag.flagName] = [...flag.alias];
+            if (flag.parse !== undefined) {
+                flagsParserOptions.coerce[flag.flagName] = flag.parse;
+            }
+            if (flag.default !== undefined)
+                flagsParserOptions.default[flag.flagName] = flag.default;
+            flagsParserOptions[flag.type].push(flag.flagName);
+        }
+        return {
+            flagsParserOptions,
+            argumentsParserOptions: this.args.map((arg) => ({
+                type: arg.type,
+                default: arg.default,
+                parse: arg.parse,
+            })),
+        };
+    }
+    /**
+     * Check a parsed input against this command's declarations (Console `validate`).
+     *
+     * The parser enforces the same rules while parsing, so calling this on its
+     * output always passes. It is here for the case Console documents: an input built
+     * by hand, which has never been through a parser.
+     *
+     * Positional values are accepted as a list (Console's shape) or keyed by property
+     * name (what `this.parsed.args` holds), so the same call works from both.
+     */
+    static validate(parsed) {
+        this.boot();
+        // The kernel applies the same rules between parsing and running — see
+        // `validateParsed`. One implementation, so a hand-built input is held to
+        // exactly what the command line is held to.
+        validateParsed(parsed, {
+            args: this.args,
+            flags: this.flags,
+            allowUnknownFlags: this.options.allowUnknownFlags,
+            commandName: this.commandName,
+        });
+    }
+    /**
+     * Assign the parsed values to their properties (Console `hydrate`).
+     *
+     * Idempotent: the kernel calls it before `run()`, and a ported command may
+     * call it again without the values being recomputed.
+     */
+    hydrate() {
+        if (this.hydrated)
+            return;
+        const commandClass = Object.getPrototypeOf(this).constructor;
+        if (!isDeclaring(commandClass)) {
+            throw new Error('hydrate() requires a command class carrying the static contract');
+        }
+        // One hydration path, shared with the kernel — see `assignParsedValues`.
+        // By declaration, not by copying the parsed bag: positionals are read BY
+        // POSITION and flags by their CLI name, so `this.name` is filled whichever
+        // shape the input came in.
+        assignParsedValues(this, commandClass.args, commandClass.flags, this.parsed);
+        this.hydrated = true;
+    }
+    /** Set once {@link hydrate} has run. */
+    hydrated = false;
+    /**
+     * Hydrate, then run — Console's instance-level `exec()`.
+     *
+     * Deliberately NOT the kernel's `exec()`: this one runs `run()` alone and
+     * rethrows, while the kernel drives the whole lifecycle (`prepare`,
+     * `interact`, `completed`) and reports the failure on the command instead.
+     */
+    async exec() {
+        this.hydrate();
+        try {
+            this.result = await this.run();
+            this.exitCode = this.exitCode ?? 0;
+            return this.result;
+        }
+        catch (error) {
+            this.error = error;
+            this.exitCode = this.exitCode ?? 1;
+            throw error;
+        }
+    }
+    /** The statics, readable from the instance (Console parity). */
+    get commandName() {
+        return Object.getPrototypeOf(this).constructor.commandName;
+    }
+    get options() {
+        return Object.getPrototypeOf(this).constructor.options;
+    }
+    get args() {
+        return Object.getPrototypeOf(this).constructor.args;
+    }
+    get flags() {
+        return Object.getPrototypeOf(this).constructor.flags;
+    }
+    /**
+     * A snapshot of THIS execution (Console `toJSON`): what the command received and
+     * what it produced.
+     *
+     * Distinct from the static {@link serialize}, which describes the command's
+     * contract. Returning the metadata here would drop `exitCode`, `result` and
+     * `error` — exactly what a test or an integration reads after running it.
+     */
+    toJSON() {
+        // Not named `constructor`: that shadows the global and biome rejects it.
+        const commandClass = Object.getPrototypeOf(this).constructor;
+        if (!isSerializable(commandClass)) {
+            throw new Error('toJSON() requires a command class carrying the static contract');
+        }
+        const meta = commandClass.serialize();
+        return {
+            commandName: meta.commandName,
+            options: meta.options,
+            // Positional VALUES as a list (Console's shape); flags stay keyed.
+            args: [...(this.parsed?.args ?? [])],
+            flags: this.parsed?.flags ?? {},
+            error: this.error,
+            result: this.result,
+            exitCode: this.exitCode,
+        };
+    }
+    // ─── Test assertions (Console parity) ───────────────────────────
+    //
+    // They live on the command because that is where a test holds the result,
+    // but the implementation is the kernel's: a command the kernel ran carries
+    // assertions ATTACHED by it (a class declared structurally never extends
+    // this one), and two copies of "did the table print this row?" is how the
+    // two answers end up disagreeing — which is exactly what happened.
+    /** The command finished with exit code 0. */
+    assertSucceeded() {
+        createAssertions(this, this.ui).assertSucceeded();
+    }
+    /** The command finished with a non-zero exit code. */
+    assertFailed() {
+        createAssertions(this, this.ui).assertFailed();
+    }
+    assertExitCode(expected) {
+        createAssertions(this, this.ui).assertExitCode(expected);
+    }
+    assertNotExitCode(unexpected) {
+        createAssertions(this, this.ui).assertNotExitCode(unexpected);
+    }
+    /**
+     * A line equal to `message` was logged. Pass a stream to require it went
+     * there — a warning belongs on stderr, and asserting that is the point.
+     */
+    assertLog(message, stream) {
+        createAssertions(this, this.ui).assertLog(message, stream);
+    }
+    assertLogMatches(pattern, stream) {
+        createAssertions(this, this.ui).assertLogMatches(pattern, stream);
+    }
+    /** Every expected row was rendered — the header counts as one (Console). */
+    assertTableRows(expected) {
+        createAssertions(this, this.ui).assertTableRows(expected);
+    }
+}
+/**
+ * The class carries the declarations `hydrate()` reads. Checked rather than
+ * assumed: a command may be declared structurally, and reading `args` off
+ * something that has none would silently hydrate nothing.
+ */
+function isDeclaring(value) {
+    return (typeof value === 'function' &&
+        Array.isArray(Reflect.get(value, 'args')) &&
+        Array.isArray(Reflect.get(value, 'flags')));
+}
+function isSerializable(value) {
+    return (typeof value === 'function' &&
+        'serialize' in value &&
+        typeof Reflect.get(value, 'serialize') === 'function');
+}
+//# sourceMappingURL=BaseCommand.js.map

package/dist/console/BaseCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCommand.js","sourceRoot":"","sources":["../../src/console/BaseCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAElD,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE/E,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAahE,MAAM,OAAgB,WAAW;IAC/B,6EAA6E;IAC7E,MAAM,CAAC,WAAW,GAAG,EAAE,CAAA;IAEvB,wCAAwC;IACxC,MAAM,CAAC,WAAW,GAAG,EAAE,CAAA;IAEvB;;;OAGG;IACH,MAAM,CAAC,OAAO,GAAsB,EAAE,CAAA;IAEtC,oEAAoE;IACpE,MAAM,CAAC,IAAI,CAAoB;IAE/B,MAAM,CAAC,OAAO,GAAmB,EAAE,CAAA;IAEnC;;;;OAIG;IACH,MAAM,CAAC,IAAI,GAAgC,EAAE,CAAA;IAC7C,MAAM,CAAC,KAAK,GAA4B,EAAE,CAAA;IAsC1C,iEAAiE;IACjE,QAAQ,CAAS;IAEjB,+EAA+E;IAC/E,MAAM,CAAU;IAEhB;;;OAGG;IACH,KAAK,CAAU;IAkBf;;;;OAIG;IACH,KAAK,CAAC,SAAS;QACb,MAAM,IAAI,CAAC,WAAW,EAAE,EAAE,CAAA;IAC5B,CAAC;IAED,0EAA0E;IAC1E,MAAM,CAAC,MAAM,GAAG,KAAK,CAAA;IAErB;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI;QACT,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI;YAAE,OAAM;QACjE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QAClB,+EAA+E;QAC/E,sEAAsE;QACtE,sEAAsE;QACtE,IAAI,CAAC,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAA;QAC5B,IAAI,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAA;QAChC,IAAI,CAAC,OAAO,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;IACjF,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,IAAY,EAAE,UAAqC,EAAE;QACzE,IAAI,CAAC,IAAI,EAAE,CAAA;QACX,MAAM,IAAI,GAAuB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAA;QAC/C,2EAA2E;QAC3E,0EAA0E;QAC1E,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QAE7C,iEAAiE;QACjE,2EAA2E;QAC3E,wEAAwE;QACxE,0EAA0E;QAC1E,gCAAgC;QAChC,mBAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QAEnC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;IAED,iEAAiE;IACjE,MAAM,CAAC,UAAU,CAAC,IAAY,EAAE,UAAiC,EAAE;QACjE,IAAI,CAAC,IAAI,EAAE,CAAA;QACX,MAAM,IAAI,GAAmB,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAA;QAC5C,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAA;QACnC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IACnB,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS;QACd,IAAI,CAAC,IAAI,EAAE,CAAA;QACX,0EAA0E;QAC1E,6DAA6D;QAC7D,MAAM,YAAY,GAAG,CAAgC,KAAQ,EAAoB,EAAE;YACjF,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAA;YAC1C,OAAO,IAAI,CAAA;QACb,CAAC,CAAA;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAE3C,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,SAAS,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;YACjE,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;YAC1B,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE;YAC5B,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;YACjC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC;SACpC,CAAA;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAqC;QAI3D,IAAI,CAAC,IAAI,EAAE,CAAA;QAEX,MAAM,kBAAkB,GAAuB;YAC7C,GAAG,EAAE,EAAE;YACP,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,EAAE;YACX,MAAM,EAAE,EAAE;YACV,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,EAAE;YACT,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,EAAE;YACX,GAAG,OAAO;SACX,CAAA;QAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC1C,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;gBAAE,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAA;YACpF,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC7B,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,KAAkC,CAAA;YACpF,CAAC;YACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;gBAAE,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,OAAO,CAAA;YACxF,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACnD,CAAC;QAED,OAAO;YACL,kBAAkB;YAClB,sBAAsB,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAC9C,IAAI,EAAE,GAAG,CAAC,IAAI;gBACd,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,KAAK,EAAE,GAAG,CAAC,KAAK;aACjB,CAAC,CAAC;SACJ,CAAA;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,QAAQ,CAAC,MAIf;QACC,IAAI,CAAC,IAAI,EAAE,CAAA;QACX,sEAAsE;QACtE,yEAAyE;QACzE,4CAA4C;QAC5C,cAAc,CAAC,MAAM,EAAE;YACrB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;YACjD,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAM;QACzB,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAA;QAC5D,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAA;QACpF,CAAC;QAED,yEAAyE;QACzE,yEAAyE;QACzE,2EAA2E;QAC3E,2BAA2B;QAC3B,kBAAkB,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAE5E,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC;IAED,wCAAwC;IAC9B,QAAQ,GAAG,KAAK,CAAA;IAE1B;;;;;;OAMG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,OAAO,EAAE,CAAA;QACd,IAAI,CAAC;YACH,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,CAAA;YAC9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAA;YAClC,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;YAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAA;YAClC,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED,gEAAgE;IAChE,IAAI,WAAW;QACb,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,WAAW,CAAA;IAC5D,CAAC;IAED,IAAI,OAAO;QACT,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,OAAO,CAAA;IACxD,CAAC;IAED,IAAI,IAAI;QACN,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,IAAI,CAAA;IACrD,CAAC;IAED,IAAI,KAAK;QACP,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,KAAK,CAAA;IACtD,CAAC;IAED;;;;;;;OAOG;IACH,MAAM;QACJ,yEAAyE;QACzE,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,WAAW,CAAA;QAC5D,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;QACnF,CAAC;QACD,MAAM,IAAI,GAAG,YAAY,CAAC,SAAS,EAAE,CAAA;QAErC,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,mEAAmE;YACnE,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;YACpC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE;YAC/B,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAA;IACH,CAAC;IAUD,mEAAmE;IACnE,EAAE;IACF,0EAA0E;IAC1E,2EAA2E;IAC3E,yEAAyE;IACzE,0EAA0E;IAC1E,mEAAmE;IAEnE,6CAA6C;IAC7C,eAAe;QACb,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,eAAe,EAAE,CAAA;IACnD,CAAC;IAED,sDAAsD;IACtD,YAAY;QACV,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,YAAY,EAAE,CAAA;IAChD,CAAC;IAED,cAAc,CAAC,QAAgB;QAC7B,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;IAC1D,CAAC;IAED,iBAAiB,CAAC,UAAkB;QAClC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAA;IAC/D,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,OAAe,EAAE,MAA4B;QACrD,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAC5D,CAAC;IAED,gBAAgB,CAAC,OAAe,EAAE,MAA4B;QAC5D,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IACnE,CAAC;IAED,4EAA4E;IAC5E,eAAe,CAAC,QAAwC;QACtD,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAA;IAC3D,CAAC;;AAGH;;;;GAIG;AACH,SAAS,WAAW,CAClB,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,UAAU;QAC3B,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACzC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAC3C,CAAA;AACH,CAAC;AAED,SAAS,cAAc,CAAC,KAAc;IACpC,OAAO,CACL,OAAO,KAAK,KAAK,UAAU;QAC3B,WAAW,IAAI,KAAK;QACpB,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,KAAK,UAAU,CACtD,CAAA;AACH,CAAC"}

package/dist/console/Console.d.ts

@@ -0,0 +1,86 @@
+/**
+ * `consoleApp` — the programmatic face of the console.
+ *
+ * The CLI is not the only caller: a test wants to run a command and inspect the
+ * result, a controller may want to trigger one, a script may want to check a
+ * command exists before calling it. Spawning a process for that is both slow
+ * and untestable.
+ *
+ *   import consoleApp from '@c9up/ream/services/console'
+ *
+ *   const command = await consoleApp.exec('make:controller', ['user', '--resource'])
+ *   command.exitCode  // 0 on success, 1 on an unhandled failure
+ *   command.result    // whatever run() returned
+ *   command.error     // the failure, when one survived completed()
+ */
+import type { Ui } from './cliui.js';
+import type { Kernel, KernelState } from './Kernel.js';
+import type { CommandClass, CommandInstance, ExecutedCommand, SerializedCommand } from './types.js';
+export interface ConsoleOptions {
+    kernel: Kernel;
+    /**
+     * Loads the application's commands into the kernel. Called once, on first
+     * use — discovery reads the filesystem and imports modules, which is too much
+     * to do at every `hasCommand()`.
+     */
+    load: () => Promise<void>;
+}
+export declare class Console {
+    #private;
+    constructor(options: ConsoleOptions);
+    /**
+     * Load the commands if that has not happened yet.
+     *
+     * Idempotent, and safe under concurrent calls: the in-flight promise is
+     * shared, so two parallel `exec()` calls do not each import every command.
+     */
+    boot(): Promise<void>;
+    /** Run a command and return it, carrying `exitCode`, `result` and `error`. */
+    exec(commandName: string, argv?: readonly string[], options?: {
+        ui?: Ui;
+    }): Promise<ExecutedCommand>;
+    /**
+     * Does a command (or alias) by this name exist?
+     *
+     * Synchronous, as in Console — `await consoleApp.boot()` then `if (consoleApp.hasCommand(…))`.
+     * An async version would be a trap: a Promise is always truthy, so Adonis
+     * code copied over would take every branch.
+     *
+     * Calling it before `boot()` throws rather than answering `false`: an
+     * unloaded registry cannot tell "no such command" from "not looked yet", and
+     * a silent `false` is exactly the failure this signature exists to avoid.
+     */
+    hasCommand(name: string): boolean;
+    /** The metadata of every registered command. Requires {@link boot} too. */
+    getCommands(): SerializedCommand[];
+    /**
+     * The rest of Console's introspection surface, relayed as-is.
+     *
+     * All of it reads the registry, so all of it needs {@link boot} first —
+     * answering from an empty registry would be worse than the error, since
+     * "no such command" and "commands not loaded yet" are indistinguishable to
+     * the caller.
+     */
+    getCommand(commandName: string): SerializedCommand | null;
+    getNamespaceCommands(namespace?: string): SerializedCommand[];
+    getNamespaces(): string[];
+    getAliases(): string[];
+    getAliasCommand(alias: string): SerializedCommand | null;
+    getCommandAliases(commandName: string): string[];
+    getCommandSuggestions(name: string): string[];
+    getNamespaceSuggestions(name: string): string[];
+    /** The kernel's lifecycle stage — Console `getState()`. */
+    getState(): KernelState;
+    /** The command run when none is named. */
+    getDefaultCommand(): CommandClass;
+    /** The command invoked from the command line, once it has been built. */
+    getMainCommand(): CommandInstance | undefined;
+    /**
+     * Resolve a command class by name or alias, throwing when there is none.
+     * Loads the commands first, like {@link exec}.
+     */
+    find(commandName: string): Promise<CommandClass>;
+    /** The underlying kernel, for anything the façade does not cover. */
+    get kernel(): Kernel;
+}
+//# sourceMappingURL=Console.d.ts.map

package/dist/console/Console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Console.d.ts","sourceRoot":"","sources":["../../src/console/Console.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnG,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,qBAAa,OAAO;;gBAMN,OAAO,EAAE,cAAc;IAKnC;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,8EAA8E;IACxE,IAAI,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,GAAE,SAAS,MAAM,EAAO,EAC5B,OAAO,GAAE;QAAE,EAAE,CAAC,EAAE,EAAE,CAAA;KAAO,GACxB,OAAO,CAAC,eAAe,CAAC;IAK3B;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAKjC,2EAA2E;IAC3E,WAAW,IAAI,iBAAiB,EAAE;IAKlC;;;;;;;OAOG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAKzD,oBAAoB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAK7D,aAAa,IAAI,MAAM,EAAE;IAKzB,UAAU,IAAI,MAAM,EAAE;IAKtB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAKxD,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE;IAKhD,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAK7C,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAK/C,2DAA2D;IAC3D,QAAQ,IAAI,WAAW;IAIvB,0CAA0C;IAC1C,iBAAiB,IAAI,YAAY;IAKjC,yEAAyE;IACzE,cAAc,IAAI,eAAe,GAAG,SAAS;IAI7C;;;OAGG;IACG,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IActD,qEAAqE;IACrE,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}