@strav/cli 0.4.31 → 1.0.0-alpha.4

package/package.json

@@ -1,52 +1,28 @@
 {
   "name": "@strav/cli",
-  "version": "0.4.31",
+  "version": "1.0.0-alpha.4",
+  "description": "Strav CLI layer — Command base, signature parser, ConsoleProvider, interactive prompts on top of @strav/kernel's ConsoleKernel",
   "type": "module",
-  "description": "CLI framework and code generators for the Strav framework",
-  "license": "MIT",
-  "keywords": [
-    "bun",
-    "framework",
-    "typescript",
-    "strav",
-    "cli"
-  ],
-  "strav": {
-    "commands": "src/commands"
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
   },
   "files": [
-    "src/",
-    "package.json",
-    "tsconfig.json",
-    "CHANGELOG.md"
+    "src",
+    "README.md"
   ],
-  "exports": {
-    ".": "./src/index.ts",
-    "./cli": "./src/cli/index.ts",
-    "./cli/*": "./src/cli/*.ts",
-    "./commands": "./src/commands/index.ts",
-    "./commands/*": "./src/commands/*.ts",
-    "./config/*": "./src/config/*.ts",
-    "./generators": "./src/generators/index.ts",
-    "./generators/*": "./src/generators/*.ts"
+  "engines": {
+    "bun": ">=1.3.14"
   },
-  "bin": {
-    "strav": "./src/cli/strav.ts"
-  },
-  "peerDependencies": {
-    "@strav/kernel": "0.4.31",
-    "@strav/http": "0.4.31",
-    "@strav/database": "0.4.31",
-    "@strav/queue": "0.4.31",
-    "@strav/signal": "0.4.31"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "chalk": "^5.6.2",
-    "commander": "^14.0.3",
-    "prettier": "^3.8.1"
+    "@strav/kernel": "1.0.0-alpha.4"
+  },
+  "peerDependencies": {
+    "@types/bun": ">=1.3.14"
   },
-  "scripts": {
-    "test": "bun test tests/",
-    "typecheck": "tsc --noEmit"
-  }
+  "devDependencies": null
 }

package/src/binder.ts

@@ -0,0 +1,88 @@
+/**
+ * Argv binder — given a parsed `Signature` and the kernel's `ParsedArgv`,
+ * produce the `{ args, flags }` shape `Command.execute()` receives.
+ *
+ * Validation is loud-fail (`UsageError`) so wrong invocations land an exit
+ * code 2 with a clear message rather than a `TypeError` from `args.foo`:
+ *   - Required positional missing → "missing argument: <name>".
+ *   - Extra positional after all declared → "unexpected argument: <value>".
+ *   - String flag with no value (bare `--output`) → "flag --output requires a value".
+ *
+ * Unknown flags (passed but not declared) are *retained* in the output —
+ * commands may inspect them via `flags[<unknown>]`, which is the escape
+ * hatch for ad-hoc flags without growing the signature. They never error.
+ */
+
+import { type ParsedArgv, StravError, type StravErrorOptions } from '@strav/kernel'
+import type { Signature } from './signature.ts'
+
+/**
+ * Thrown when argv doesn't match a `Signature` — missing required positional,
+ * unexpected extra positional, or a value-flag with no value. Status 2 mirrors
+ * the POSIX "usage error" exit-code convention; the CliConsoleKernel surfaces
+ * it as exit code 2.
+ */
+export class UsageError extends StravError {
+  constructor(message: string, options: StravErrorOptions = {}) {
+    super(message, { code: 'cli.usage', status: 2 }, options)
+  }
+}
+
+export interface BoundArgv {
+  args: Record<string, string | undefined>
+  flags: Record<string, string | boolean>
+}
+
+export function bindArgv(signature: Signature, parsed: ParsedArgv): BoundArgv {
+  const args: Record<string, string | undefined> = {}
+  const flags: Record<string, string | boolean> = {}
+
+  // ─── positionals ────────────────────────────────────────────────────────────
+  for (let i = 0; i < signature.args.length; i++) {
+    const spec = signature.args[i]
+    if (!spec) continue
+    const value = parsed.args[i]
+    if (value === undefined) {
+      if (!spec.optional) {
+        throw new UsageError(`missing argument: <${spec.name}>`)
+      }
+      args[spec.name] = undefined
+    } else {
+      args[spec.name] = value
+    }
+  }
+
+  if (parsed.args.length > signature.args.length) {
+    const extra = parsed.args[signature.args.length]
+    throw new UsageError(`unexpected argument: "${extra}"`)
+  }
+
+  // ─── declared flags ─────────────────────────────────────────────────────────
+  const declaredFlagNames = new Set<string>()
+  for (const spec of signature.flags) {
+    declaredFlagNames.add(spec.name)
+    const raw = parsed.flags[spec.name]
+    if (raw === undefined) {
+      flags[spec.name] = spec.default
+      continue
+    }
+    if (spec.kind === 'boolean') {
+      // Bare `--flag` parses as `true`; an explicit `--flag=foo` also flips
+      // it to true (the value is meaningless for a boolean — we ignore it
+      // rather than error so `--verbose=1` from CI scripts doesn't surprise).
+      flags[spec.name] = raw !== false
+    } else {
+      if (raw === true) {
+        throw new UsageError(`flag --${spec.name} requires a value`)
+      }
+      flags[spec.name] = raw
+    }
+  }
+
+  // ─── undeclared flags (pass through) ────────────────────────────────────────
+  for (const [name, value] of Object.entries(parsed.flags)) {
+    if (!declaredFlagNames.has(name)) flags[name] = value
+  }
+
+  return { args, flags }
+}

package/src/command.ts

@@ -0,0 +1,297 @@
+/**
+ * `Command` — base class for CLI commands.
+ *
+ * Wraps `@strav/kernel`'s minimal `Command` (which exposes `handle(ctx)` with
+ * positional `args: readonly string[]`) and adds:
+ *   - The signature DSL (`'cmd {arg} {arg?} {--flag=default}'`), parsed once
+ *     at registration time. `execute({ args, flags })` receives the bound
+ *     values keyed by name.
+ *   - Output helpers as instance methods (`this.info` / `this.warn` / …) so
+ *     command bodies stay declarative without threading the writer around.
+ *   - Interactive prompts (`this.confirm`, `this.ask`, `this.choice`,
+ *     `this.table`) backed by Bun's stdin reader.
+ *   - `static providers?: string[]` — names of providers to boot. Resolved
+ *     by the `CliConsoleKernel` against the default list (transitive deps
+ *     auto-included). Omit for "boot everything"; `[]` for "boot nothing".
+ *
+ * Subclasses implement `execute(args)` and return a number (exit code) or
+ * void (treated as 0). Errors thrown from `execute()` bubble up to the
+ * kernel, which surfaces them via stderr + returns exit 1.
+ */
+
+import {
+  type Application,
+  type CommandContext,
+  type CommandResult,
+  Command as KernelCommand,
+} from '@strav/kernel'
+import { bindArgv, UsageError } from './binder.ts'
+import { ExitCode } from './exit_codes.ts'
+import { parseSignature, type Signature } from './signature.ts'
+
+export interface ExecuteArgs {
+  /** Positional args, keyed by name (from `{name}` in the signature). */
+  args: Record<string, string | undefined>
+  /**
+   * Parsed flags, keyed by name. Boolean flags resolve to `false` by default;
+   * string flags to their declared default. Undeclared flags pass through.
+   */
+  flags: Record<string, string | boolean>
+}
+
+/**
+ * Static metadata every CLI command must declare. The richer `signature` is
+ * the source of truth for argv binding — the bare command name is derived
+ * from its first token. `description` is the one-liner shown by `list`.
+ */
+export interface CliCommandMeta {
+  readonly signature: string
+  readonly description: string
+  /**
+   * Subset of provider names to boot for this command. Omitted = full default
+   * list. `[]` = none. See `docs/cli/guides/subset-boot.md`.
+   */
+  readonly providers?: readonly string[]
+}
+
+export abstract class Command extends KernelCommand {
+  /** Lazily-built `Signature` from `static signature`. Re-used across handle() calls. */
+  private static signatureCache: WeakMap<typeof Command, Signature> = new WeakMap()
+
+  static parsedSignature(): Signature {
+    // `this` here refers to the SUBCLASS that called .parsedSignature(), which
+    // is what we want — the cache keys per-subclass so each command parses its
+    // signature once. Using the literal `Command` name would collapse all
+    // subclasses to the same key.
+    // biome-ignore lint/complexity/noThisInStatic: intentional subclass-aware cache
+    const Class = this as typeof Command
+    const cached = Command.signatureCache.get(Class)
+    if (cached) return cached
+    const raw = (Class as { signature?: unknown }).signature
+    if (typeof raw !== 'string') {
+      throw new Error(
+        `${Class.name}: missing static \`signature\` string — every Command needs one`,
+      )
+    }
+    const parsed = parseSignature(raw)
+    Command.signatureCache.set(Class, parsed)
+    return parsed
+  }
+
+  /** Kernel calls this with positional argv; we re-bind via the signature and call `execute()`. */
+  // biome-ignore lint/suspicious/noConfusingVoidType: matches kernel's CommandResult — void means "treat as 0"
+  override async handle(ctx: CommandContext): Promise<number | void> {
+    const Class = this.constructor as typeof Command
+    const signature = Class.parsedSignature()
+    this.output = ctx.out
+    this.app = ctx.app
+
+    // `<cmd> --help` short-circuits to per-command help.
+    if (ctx.flags.help === true || ctx.flags.h === true) {
+      this.printHelp()
+      return 0
+    }
+
+    // UsageError → POSIX exit code 2 + per-command usage line on stderr.
+    // The catch covers BOTH the binder (signature mismatch) AND execute()
+    // itself — commands often validate flag values after binding (e.g.,
+    // `--batch=not-a-number`) and throw UsageError. Other exceptions still
+    // get the kernel's generic exit-1 + stack-trace treatment.
+    try {
+      const bound = bindArgv(signature, {
+        command: signature.name,
+        args: [...ctx.args],
+        flags: { ...ctx.flags },
+      })
+      return await this.execute(bound)
+    } catch (err) {
+      if (err instanceof UsageError) {
+        this.error(err.message)
+        this.error(`Usage: ${formatUsage(signature)}`)
+        return ExitCode.UsageError
+      }
+      throw err
+    }
+  }
+
+  /**
+   * Print the help message for this command. Composed from `static description`
+   * + the parsed signature + the optional `help()` override.
+   */
+  protected printHelp(): void {
+    const Class = this.constructor as typeof Command
+    const signature = Class.parsedSignature()
+    const description = (Class as { description?: unknown }).description
+    if (typeof description === 'string' && description.length > 0) {
+      this.line(description)
+      this.line()
+    }
+    this.line(`Usage: ${formatUsage(signature)}`)
+    if (signature.args.length > 0) {
+      this.line()
+      this.line('Arguments:')
+      for (const arg of signature.args) {
+        this.line(`  ${arg.name}${arg.optional ? '?' : ''}`)
+      }
+    }
+    if (signature.flags.length > 0) {
+      this.line()
+      this.line('Flags:')
+      for (const flag of signature.flags) {
+        const suffix = flag.kind === 'string' ? `=<value> (default: ${flag.default})` : ' (boolean)'
+        this.line(`  --${flag.name}${suffix}`)
+      }
+    }
+    const extra = this.help()
+    if (extra) {
+      this.line()
+      this.line(extra)
+    }
+  }
+
+  /** Set by `handle()` before calling `execute()`. */
+  protected output!: CommandContext['out']
+  /**
+   * The booted `Application` — set by `handle()` before `execute()` runs.
+   * Use it to resolve services that don't fit through constructor injection
+   * (e.g., when a command's deps are dynamic, or when subset boot binds a
+   * service that the command's static `@inject()` doesn't know about).
+   */
+  protected app!: Application
+
+  /** Implement the command. Return a number for an explicit exit code, void for 0. */
+  abstract execute(argv: ExecuteArgs): CommandResult
+
+  // ─── output helpers — thin wrappers around ConsoleOutput ─────────────────────
+
+  protected info(msg: string): void {
+    this.output.info(msg)
+  }
+  protected success(msg: string): void {
+    this.output.success(msg)
+  }
+  protected warn(msg: string): void {
+    this.output.warn(msg)
+  }
+  protected error(msg: string): void {
+    this.output.error(msg)
+  }
+  protected line(msg = ''): void {
+    this.output.line(msg)
+  }
+
+  /**
+   * Print a table with aligned columns. Headers + every row are stringified;
+   * column widths derived from the widest cell. Apps that need fancier
+   * tables write to `this.output` directly.
+   */
+  protected table(headers: readonly string[], rows: readonly (readonly string[])[]): void {
+    const widths = headers.map((h, i) =>
+      Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)),
+    )
+    const fmt = (cells: readonly string[]) =>
+      cells.map((c, i) => (c ?? '').padEnd(widths[i] ?? 0)).join('  ')
+    this.line(fmt(headers))
+    this.line(widths.map((w) => '-'.repeat(w)).join('  '))
+    for (const row of rows) this.line(fmt(row))
+  }
+
+  /**
+   * Yes/no prompt. Accepts `y`/`yes` (case-insensitive) as `true`; anything
+   * else (including empty input) as `false`. Use `defaultYes: true` to flip
+   * empty input to `true`.
+   */
+  protected async confirm(question: string, opts: { defaultYes?: boolean } = {}): Promise<boolean> {
+    const suffix = opts.defaultYes ? ' [Y/n] ' : ' [y/N] '
+    this.output.write(`${question}${suffix}`)
+    const answer = (await readStdinLine()).trim().toLowerCase()
+    if (answer === '') return opts.defaultYes ?? false
+    return answer === 'y' || answer === 'yes'
+  }
+
+  /** Free-text prompt. Returns the default when the user just hits enter. */
+  protected async ask(question: string, defaultValue?: string): Promise<string> {
+    const suffix = defaultValue !== undefined ? ` [${defaultValue}] ` : ' '
+    this.output.write(`${question}${suffix}`)
+    const answer = (await readStdinLine()).trim()
+    if (answer === '') return defaultValue ?? ''
+    return answer
+  }
+
+  /**
+   * Multiple-choice prompt — prints options as a numbered list, accepts
+   * either the number or the option text. Re-prompts on bad input.
+   */
+  protected async choice<T extends string>(
+    question: string,
+    options: readonly T[],
+    defaultValue?: T,
+  ): Promise<T> {
+    if (options.length === 0) {
+      throw new Error('choice(): options must be non-empty')
+    }
+    while (true) {
+      this.line(question)
+      for (let i = 0; i < options.length; i++) {
+        const marker = options[i] === defaultValue ? ' (default)' : ''
+        this.line(`  ${i + 1}. ${options[i]}${marker}`)
+      }
+      this.output.write('> ')
+      const raw = (await readStdinLine()).trim()
+      if (raw === '' && defaultValue !== undefined) return defaultValue
+      const asNum = Number.parseInt(raw, 10)
+      if (Number.isInteger(asNum) && asNum >= 1 && asNum <= options.length) {
+        return options[asNum - 1] as T
+      }
+      const match = options.find((o) => o === raw)
+      if (match !== undefined) return match
+      this.warn(`Invalid choice: "${raw}"`)
+    }
+  }
+
+  /** Optional per-command help text. Override to provide examples / extra detail. */
+  help(): string | undefined {
+    return undefined
+  }
+}
+
+/** Render `cmd {arg} {arg?} [--flag=…]` from a parsed signature for help output. */
+function formatUsage(signature: Signature): string {
+  const parts: string[] = [signature.name]
+  for (const arg of signature.args) parts.push(arg.optional ? `[${arg.name}]` : `<${arg.name}>`)
+  for (const flag of signature.flags) {
+    parts.push(flag.kind === 'string' ? `[--${flag.name}=…]` : `[--${flag.name}]`)
+  }
+  return parts.join(' ')
+}
+
+/**
+ * Read one line from stdin. Returns the empty string at EOF. Decoded as UTF-8.
+ *
+ * Bun's `console.readLine()` blocks the event loop; this uses the `for await`
+ * stream interface so other async work (e.g., a spinner) can run alongside.
+ */
+async function readStdinLine(): Promise<string> {
+  let buf = ''
+  const decoder = new TextDecoder()
+  for await (const chunk of Bun.stdin.stream()) {
+    buf += decoder.decode(chunk, { stream: true })
+    const newline = buf.indexOf('\n')
+    if (newline !== -1) {
+      return buf.slice(0, newline).replace(/\r$/, '')
+    }
+  }
+  buf += decoder.decode()
+  return buf.replace(/\r$/, '')
+}
+
+/**
+ * Constructor type the `CliConsoleKernel` accepts. Combines the runtime
+ * constructor (so the container can `make()` it) with the static metadata
+ * the kernel reads at registration / dispatch time.
+ */
+export type CliCommandClass<T extends Command = Command> = (new (
+  // biome-ignore lint/suspicious/noExplicitAny: structural ctor — Command subclasses vary in injected deps
+  ...args: any[]
+) => T) &
+  CliCommandMeta

package/src/config_list.ts

@@ -0,0 +1,42 @@
+/**
+ * `bun strav config:list` — list every top-level config namespace.
+ *
+ * Useful for sanity-checking what `ConfigProvider` actually loaded —
+ * e.g., confirming that `config.auth` is present after wiring a new
+ * provider, or seeing which app sections are populated in production
+ * vs. development.
+ *
+ * Pairs with `config:show <key>` for drilling in. Outputs one
+ * namespace per line, alphabetically sorted, with a trailing `(empty)`
+ * marker for namespaces whose value is `undefined` / `null` / an empty
+ * object.
+ */
+
+import { ConfigRepository } from '@strav/kernel'
+import { Command } from './command.ts'
+import { ExitCode } from './exit_codes.ts'
+
+export class ConfigList extends Command {
+  static signature = 'config:list'
+  static description = 'List top-level config namespaces (app, auth, database, …).'
+  static providers = ['config']
+
+  override execute(): number {
+    const all = this.app.resolve(ConfigRepository).all()
+    const keys = Object.keys(all).sort()
+
+    if (keys.length === 0) {
+      this.info('No config namespaces are loaded.')
+      return ExitCode.Success
+    }
+
+    for (const key of keys) {
+      const value = all[key]
+      const empty =
+        value == null ||
+        (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0)
+      this.line(empty ? `${key} (empty)` : key)
+    }
+    return ExitCode.Success
+  }
+}

package/src/config_show.ts

@@ -0,0 +1,50 @@
+/**
+ * `bun strav config:show <key>` — print a single config value by dot-path.
+ *
+ * Resolves the value through `ConfigRepository.get`, which means apps see
+ * the same lookup semantics here as in their providers — including any
+ * env-var indirection / config decorators applied at boot.
+ *
+ * `--json` prints a compact JSON encoding (objects, arrays, numbers, …).
+ * The default formatter handles scalars and objects sensibly so common
+ * lookups (`config:show app.url`) "just work" without `--json`.
+ *
+ * Secret values: this command does **no** redaction. Apps that want to
+ * audit secret access from the CLI should wrap config access in their
+ * own provider or rely on the logger's redaction config when piping the
+ * output to logs.
+ */
+
+import { ConfigRepository } from '@strav/kernel'
+import { Command, type ExecuteArgs } from './command.ts'
+import { ExitCode } from './exit_codes.ts'
+
+export class ConfigShow extends Command {
+  static signature = 'config:show {key} {--json}'
+  static description = 'Print a config value by dot-path (e.g. config:show app.url).'
+  static providers = ['config']
+
+  override execute({ args, flags }: ExecuteArgs): number {
+    const key = args.key as string
+    const value = this.app.resolve(ConfigRepository).get(key)
+
+    if (value === undefined) {
+      this.error(`Config key not set: ${key}`)
+      return ExitCode.DataError
+    }
+
+    if (flags.json === true) {
+      this.line(JSON.stringify(value))
+      return ExitCode.Success
+    }
+
+    if (value === null || typeof value !== 'object') {
+      this.line(String(value))
+      return ExitCode.Success
+    }
+
+    // Objects / arrays — pretty-print so nested config is readable.
+    this.line(JSON.stringify(value, null, 2))
+    return ExitCode.Success
+  }
+}

package/src/console_provider.ts

@@ -0,0 +1,46 @@
+/**
+ * `ConsoleProvider` — declares a set of console `Command` classes the app
+ * registers with the `CliConsoleKernel`.
+ *
+ * Apps subclass it once in `app/providers/console_provider.ts`:
+ *
+ * ```ts
+ * import { ConsoleProvider } from '@strav/cli'
+ * import { TenantBackup } from '../console/commands/tenant_backup.ts'
+ *
+ * export class AppConsoleProvider extends ConsoleProvider {
+ *   override readonly name = 'console.app'
+ *   override readonly commands = [TenantBackup] as const
+ * }
+ * ```
+ *
+ * `runCli({ defaultProviders })` walks the provider list once, pulls every
+ * `commands` array off subclasses, and hands the union to the
+ * `CliConsoleKernel`. Apps don't have to wire commands a second time.
+ *
+ * The provider doesn't do anything at `register()` — command collection
+ * happens before the app boots so subset-boot (`static providers`) can
+ * pre-filter the provider list.
+ */
+
+import { ServiceProvider } from '@strav/kernel'
+import type { CliCommandClass } from './command.ts'
+
+export abstract class ConsoleProvider extends ServiceProvider {
+  /** Commands this provider contributes. Override in subclasses. */
+  readonly commands: readonly CliCommandClass[] = []
+}
+
+/**
+ * Collect every command across an ordered provider list. Order matches the
+ * iteration; duplicate-by-signature is caught later by `CliConsoleKernel`.
+ */
+export function collectCommands(providers: readonly ServiceProvider[]): CliCommandClass[] {
+  const out: CliCommandClass[] = []
+  for (const provider of providers) {
+    if (provider instanceof ConsoleProvider) {
+      out.push(...provider.commands)
+    }
+  }
+  return out
+}

package/src/exit_codes.ts

@@ -0,0 +1,26 @@
+/**
+ * POSIX-aligned exit-code constants. Commands return one of these (or any
+ * number ≥ 100 for command-specific failures); the framework defaults to
+ * 0 when `execute()` returns `void` and 1 when an error escapes.
+ *
+ * Apps reach for these via `import { ExitCode } from '@strav/cli'` so the
+ * call site reads `return ExitCode.UsageError` instead of a magic `2`.
+ */
+
+export const ExitCode = {
+  /** Success. */
+  Success: 0,
+  /** Unspecified failure. The kernel uses this when an exception escapes. */
+  GenericFailure: 1,
+  /**
+   * Argv didn't match the command's signature — missing positional, extra
+   * positional, value-flag with no value. Thrown by the binder as `UsageError`.
+   */
+  UsageError: 2,
+  /** Configuration is invalid or missing (e.g., `APP_KEY` unset). */
+  ConfigError: 64,
+  /** Data dependency unavailable (DB unreachable, file missing). */
+  DataError: 65,
+} as const
+
+export type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode]

package/src/index.ts

@@ -1,2 +1,60 @@
-export * from './cli/index.ts'
-export * from './generators/index.ts'
+// Public API of @strav/cli.
+//
+// Adds the signature DSL (`'cmd {arg} {arg?} {--flag=default}'`), a richer
+// `Command` base with output helpers + interactive prompts, `ConsoleProvider`
+// for command registration, subset boot (`static providers = [...]`), and
+// `runCli` as the entry point for `bin/strav.ts`.
+//
+// Built on @strav/kernel's `Command` / `ConsoleKernel` — those stay as the
+// minimal infrastructure; @strav/cli is the productive developer surface.
+//
+// Deferred to post-M4 slices (each lands when its underlying package does):
+//   - `cache:*` — needs `@strav/cache` (not yet a package)
+//   - `tenant:*` — needs a generic tenant-CRUD convention or app-side hooks
+//   - `plugin:install` — needs `package.json#strav` metadata convention
+
+export { type BoundArgv, bindArgv, UsageError } from './binder.ts'
+export {
+  type CliCommandClass,
+  type CliCommandMeta,
+  Command,
+  type ExecuteArgs,
+} from './command.ts'
+export { ConsoleProvider, collectCommands } from './console_provider.ts'
+export { ConfigList } from './config_list.ts'
+export { ConfigShow } from './config_show.ts'
+export { ExitCode, type ExitCodeValue } from './exit_codes.ts'
+export { KeyGenerate } from './key_generate.ts'
+export {
+  MakeCommandFile,
+  MakeController,
+  MakeFactory,
+  MakeJob,
+  MakeMail,
+  MakeMiddleware,
+  MakeMigration,
+  MakeModel,
+  MakeNotification,
+  MakePolicy,
+  MakeProvider,
+  MakeRepository,
+  MakeRequest,
+  MakeSeeder,
+  MakeTest,
+} from './make/index.ts'
+export {
+  camel,
+  MakeCommand as MakeCommandBase,
+  pascal,
+  snake,
+} from './make_command.ts'
+export { type RunCliOptions, runCli } from './run_cli.ts'
+export { ScaffoldConsoleProvider } from './scaffold_console_provider.ts'
+export {
+  type FlagSpec,
+  type PositionalArg,
+  parseSignature,
+  type Signature,
+} from './signature.ts'
+export { selectProviders } from './subset_boot.ts'
+export { UtilConsoleProvider } from './util_console_provider.ts'