@avelonjs/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Yannelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,159 @@
+# @avelonjs/cli
+
+`@avelonjs/cli` is reeve, the official who administers an Avelon app. It is an Ink TUI on Bun that also stays fully scriptable. Reach for it to generate the application tree, sync the Next router, run Bailiff, drain errands, and ask doctor whether a push is safe.
+
+Bare `./reeve` opens the TUI. Any subcommand with arguments skips it. `--no-tui` and a non-TTY stdout force plain mode.
+
+## Installation
+
+```sh
+bun add -d @avelonjs/cli
+```
+
+Put a `reeve` bin on your PATH, or run `bunx reeve`. Application `package.json` scripts call it before Next:
+
+```json
+{
+  "scripts": {
+    "dev": "reeve route:sync && bun run --bun next dev",
+    "build": "reeve route:sync && bun run --bun next build",
+    "check": "reeve doctor"
+  }
+}
+```
+
+## Basic Usage
+
+```sh
+reeve make:model Post -mfcpw
+reeve route:sync
+reeve bailiff --explain no-orphan-query
+reeve doctor
+```
+
+Every TUI path prints the equivalent non-interactive command before running it. The header always shows app name, database driver, adapter, and environment.
+
+## Generators
+
+```
+reeve make:model Post -mfcpw
+reeve make:controller PostController --resource
+reeve make:request StorePostRequest
+reeve make:policy PostPolicy --model=Post
+reeve make:ward PostWard --model=Post
+reeve make:event PostPublished
+reeve make:listener NotifySubscribers --event=PostPublished --queued
+reeve make:errand GenerateThumbnail
+reeve make:action PublishPost
+reeve make:middleware EnsureSubscribed
+reeve make:command PruneDrafts
+reeve make:view posts/Index
+reeve make:auth
+reeve make:driver storage r2
+reeve make:package billing
+reeve make:migration create_posts_table
+reeve stub:publish
+```
+
+`stub:publish` ejects templates into `stubs/` so you change generated shape without forking the framework.
+
+`reeve make:driver storage r2` scaffolds a package with every capability `false`, methods that throw
+`unimplemented`, a wired conformance suite, and a README that already passes `docs:check`. The
+certification path is `docs/15-driver-authoring.md`.
+
+## Database, wards, routes, errands
+
+```
+reeve migrate
+reeve migrate:rollback
+reeve migrate:fresh --seed
+reeve migrate:status
+reeve schema:pull
+reeve db:seed
+reeve ward:list
+reeve ward:sync
+reeve ward:check
+reeve ward:explain Post read
+reeve route:list
+reeve route:sync
+reeve errand:work
+reeve errand:failed
+reeve errand:retry all
+reeve errand:flush
+```
+
+`migrate:fresh` names what it will destroy and requires typing the environment name when it is not `local`.
+
+## Doctor and inspect
+
+```
+reeve doctor
+reeve bailiff
+reeve bailiff --fix
+reeve capabilities
+reeve config:show
+reeve about
+reeve tinker --execute '1 + 1'
+```
+
+`doctor` aggregates Bailiff, ward coverage, environment, and the capability matrix into one exit code. `docs:check` lints every package README: required sections, TypeScript code blocks that parse, and every public export in the Method Reference table.
+
+```
+reeve docs:check
+reeve docs:check packages/cli
+reeve docs:check --workspace
+```
+
+Waive a section or export with an HTML comment in the README:
+
+```html
+<!-- docs:check-waiver: section Features -->
+<!-- docs:check-waiver: export internalHelper -->
+```
+
+## Method Reference
+
+| Method / export      | Signature                                               | Description                                                       |
+| -------------------- | ------------------------------------------------------- | ----------------------------------------------------------------- |
+| `runReeve`           | `(argv, io?) => Promise<number>`                        | CLI entry. Opens the TUI or runs a subcommand.                    |
+| `runCommand`         | `(command, argv, io) => Promise<number>`                | Dispatches one parsed command.                                    |
+| `shouldUseTui`       | `(argv, io) => boolean`                                 | True for bare TTY invocations without `--no-tui`.                 |
+| `processIO`          | `() => ReeveIO`                                         | Process cwd, stdout, TTY, and env.                                |
+| `MENU`               | `readonly MenuItem[]`                                   | TUI catalog. Every row has a scriptable `command`.                |
+| `COMMANDS`           | `string[]`                                              | Unique command names.                                             |
+| `ReeveIO`            | `interface`                                             | Testable IO: `cwd`, `stdout`, `isTTY`, `env`, optional `confirm`. |
+| `renderTui`          | `(io) => Promise<void>`                                 | Ink TUI. Prints `reeve <command>` before running a selection.     |
+| `makeModel`          | `(io, name, options) => Promise<void>`                  | Writes a model and optional `-mfcpw` siblings.                    |
+| `makeMigration`      | `(io, name) => Promise<void>`                           | Writes a timestamped driver-owned migration module.               |
+| `publishStubs`       | `(io) => Promise<readonly string[]>`                    | Ejects built-in templates into `stubs/`.                          |
+| `writeFromStub`      | `(io, stub, relative, name, extra?) => Promise<string>` | Renders a stub onto disk.                                         |
+| `studly`             | `(name) => string`                                      | PascalCase helper for generator names.                            |
+| `snake`              | `(name) => string`                                      | snake_case helper.                                                |
+| `headerBits`         | `(io) => { app, database, adapter, environment }`       | TUI header fields.                                                |
+| `checkPackageDocs`   | `(root: string) => Promise<DocsCheckResult>`            | Lints one package README against house style.                     |
+| `runDocsCheck`       | `(argv, io) => Promise<number>`                         | CLI handler for `docs:check`, including `--workspace`.            |
+| `DocsCheckResult`    | `interface`                                             | `root`, `ok`, and `findings` from one package lint.               |
+| `DocsFinding`        | `interface`                                             | One missing section, unparsed block, or missing export.           |
+| `makeDriver`         | `(io, contract, slug) => Promise<void>`                 | Scaffolds a driver package with conformance wired.                |
+| `DRIVER_CONTRACTS`   | `string[]`                                              | Contract names `make:driver` accepts.                             |
+| `DriverContractSpec` | `interface`                                             | Suite, types, capabilities, and method stubs for one contract.    |
+
+## Testing
+
+Call `runReeve` with `isTTY: false` and a captured stdout. Generators write into a temp `cwd`.
+
+```ts
+import { runReeve } from '@avelonjs/cli'
+
+const code = await runReeve(['make:model', 'Post'], {
+  cwd: tempDir,
+  stdout: { write: () => true },
+  isTTY: false,
+  env: { AVELON_ENV: 'local' },
+})
+```
+
+```sh
+bun test
+bun run typecheck
+```

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@avelonjs/cli",
+  "version": "0.1.0",
+  "private": false,
+  "description": "reeve CLI and TUI for generating and administering Avelon applications.",
+  "license": "MIT",
+  "author": "Ryan Yannelli <ryanyannelli@gmail.com>",
+  "homepage": "https://github.com/yannelli/avelon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yannelli/avelon.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/yannelli/avelon/issues"
+  },
+  "keywords": [
+    "avelon",
+    "typescript",
+    "cli",
+    "reeve"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "reeve": "./src/bin.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@avelonjs/assay": "workspace:*",
+    "@avelonjs/bailiff": "workspace:*",
+    "@avelonjs/core": "workspace:*",
+    "@avelonjs/next": "workspace:*",
+    "ink": "5.2.1",
+    "react": "18.3.1"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@types/react": "18.3.26",
+    "typescript": "5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  }
+}

package/src/bin.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { runReeve } from './index'
+
+const code = await runReeve(process.argv.slice(2))
+process.exitCode = code

package/src/commands.ts

@@ -0,0 +1,399 @@
+import { readdir, writeFile, mkdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { runSeeds } from '@avelonjs/assay'
+import { parseBailiffArgs, runBailiff } from '@avelonjs/bailiff'
+import {
+  DB,
+  Errands,
+  capabilityMatrix,
+  createKernel,
+  getConfig,
+  jobBoard,
+  resetErrands,
+} from '@avelonjs/core'
+import { NextAdapter, Route } from '@avelonjs/next'
+
+import { makeDriver } from './driver-scaffold'
+import { runDocsCheck } from './docs-check'
+import {
+  makeMigration,
+  makeModel,
+  publishStubs,
+  writeFromStub,
+  type GenerateOptions,
+} from './generate'
+import { headerBits, snake, studly, writeln, type ReeveIO } from './io'
+
+function flags(argv: readonly string[]): GenerateOptions {
+  const blob = argv.filter((arg) => arg.startsWith('-') && !arg.startsWith('--')).join('')
+  const option = (name: string): string | undefined => {
+    const prefix = `--${name}=`
+    const hit = argv.find((arg) => arg.startsWith(prefix))
+    return hit?.slice(prefix.length)
+  }
+  return {
+    migration: blob.includes('m') || argv.includes('--migration'),
+    factory: blob.includes('f') || argv.includes('--factory'),
+    controller: blob.includes('c') || argv.includes('--controller'),
+    policy: blob.includes('p') || argv.includes('--policy'),
+    ward: blob.includes('w') || argv.includes('--ward'),
+    resource: argv.includes('--resource'),
+    model: option('model'),
+    event: option('event'),
+    queued: argv.includes('--queued'),
+  }
+}
+
+function operand(argv: readonly string[], index = 0): string | undefined {
+  return argv.filter((arg) => !arg.startsWith('-'))[index]
+}
+
+async function listDir(io: ReeveIO, relative: string): Promise<string[]> {
+  try {
+    return (await readdir(join(io.cwd, relative))).sort()
+  } catch {
+    return []
+  }
+}
+
+async function loadRoutes(io: ReeveIO): Promise<void> {
+  const file = join(io.cwd, 'routes/web.ts')
+  try {
+    await readdir(join(io.cwd, 'routes'))
+    Route.reset()
+    await import(`${pathToFileURL(file).href}?t=${Date.now()}`)
+  } catch {
+    /* keep in-process registrations when routes/web.ts is absent */
+  }
+}
+
+function requireName(argv: readonly string[], usage: string): string {
+  const name = operand(argv)
+  if (name === undefined) throw new Error(usage)
+  return name
+}
+
+/** Runs one parsed `reeve` command. Returns a process exit code. */
+export async function runCommand(
+  command: string,
+  argv: readonly string[],
+  io: ReeveIO,
+): Promise<number> {
+  const options = flags(argv)
+  switch (command) {
+    case 'make:model':
+      await makeModel(io, requireName(argv, 'Usage: reeve make:model Name [-mfcpw]'), options)
+      return 0
+    case 'make:controller': {
+      const name = studly(requireName(argv, 'Usage: reeve make:controller Name [--resource]'))
+      const file = name.endsWith('Controller') ? name : `${name}Controller`
+      await writeFromStub(
+        io,
+        options.resource ? 'resource-controller.ts' : 'controller.ts',
+        `app/Http/Controllers/${file}.ts`,
+        file,
+      )
+      return 0
+    }
+    case 'make:request': {
+      const name = studly(requireName(argv, 'Usage: reeve make:request Name'))
+      await writeFromStub(io, 'request.ts', `app/Http/Requests/${name}.ts`, name)
+      return 0
+    }
+    case 'make:policy': {
+      const name = studly(requireName(argv, 'Usage: reeve make:policy Name [--model=]'))
+      const model = options.model ?? name.replace(/Policy$/, '')
+      await writeFromStub(io, 'policy.ts', `app/Policies/${name}.ts`, name, { __MODEL__: model })
+      return 0
+    }
+    case 'make:ward': {
+      const name = studly(requireName(argv, 'Usage: reeve make:ward Name [--model=]'))
+      const model = options.model ?? name.replace(/Ward$/, '')
+      await writeFromStub(io, 'ward.ts', `app/Wards/${name}.ts`, name, { __MODEL__: model })
+      return 0
+    }
+    case 'make:event': {
+      const name = studly(requireName(argv, 'Usage: reeve make:event Name'))
+      await writeFromStub(io, 'event.ts', `app/Events/${name}.ts`, name)
+      return 0
+    }
+    case 'make:listener': {
+      const name = studly(requireName(argv, 'Usage: reeve make:listener Name [--event= --queued]'))
+      await writeFromStub(io, 'listener.ts', `app/Listeners/${name}.ts`, name, {
+        __EVENT__: options.event ?? 'Event',
+        __DELIVERY__: options.queued ? 'queued' : 'sync',
+      })
+      return 0
+    }
+    case 'make:errand': {
+      const name = studly(requireName(argv, 'Usage: reeve make:errand Name'))
+      await writeFromStub(io, 'errand.ts', `app/Errands/${name}.ts`, name)
+      return 0
+    }
+    case 'make:action': {
+      const name = studly(requireName(argv, 'Usage: reeve make:action Name'))
+      await writeFromStub(io, 'action.ts', `app/Actions/${name}.ts`, name)
+      return 0
+    }
+    case 'make:middleware': {
+      const name = studly(requireName(argv, 'Usage: reeve make:middleware Name'))
+      await writeFromStub(io, 'middleware.ts', `app/Http/Middleware/${name}.ts`, name)
+      return 0
+    }
+    case 'make:command': {
+      const name = studly(requireName(argv, 'Usage: reeve make:command Name'))
+      await writeFromStub(io, 'command.ts', `app/Commands/${name}.ts`, name)
+      return 0
+    }
+    case 'make:view': {
+      const name = requireName(argv, 'Usage: reeve make:view posts/Index')
+      const pascal = name
+        .split('/')
+        .map((part) => studly(part))
+        .join('')
+      await writeFromStub(io, 'view.ts', `resources/views/${name}.ts`, pascal, {
+        __SLUG__: name.replaceAll('/', '.').toLowerCase(),
+      })
+      return 0
+    }
+    case 'make:migration':
+      await makeMigration(io, requireName(argv, 'Usage: reeve make:migration name'))
+      return 0
+    case 'make:driver': {
+      const contract = operand(argv, 0)
+      const slug = operand(argv, 1)
+      if (contract === undefined || slug === undefined)
+        throw new Error('Usage: reeve make:driver storage r2')
+      await makeDriver(io, contract, slug)
+      return 0
+    }
+    case 'make:package': {
+      const slug = snake(requireName(argv, 'Usage: reeve make:package billing'))
+      await writeFromStub(io, 'package-readme.md', `packages/${slug}/README.md`, studly(slug), {
+        __SLUG__: slug,
+      })
+      return 0
+    }
+    case 'make:auth':
+      await writeFromStub(
+        io,
+        'controller.ts',
+        'app/Http/Controllers/SessionController.ts',
+        'SessionController',
+      )
+      await writeFromStub(io, 'request.ts', 'app/Http/Requests/SignInRequest.ts', 'SignInRequest')
+      await writeFromStub(io, 'view.ts', 'resources/views/auth/SignIn.ts', 'SignIn', {
+        __SLUG__: 'auth.sign-in',
+      })
+      writeln(io, 'Auth routes, controller, request, and view stubbed.')
+      return 0
+    case 'stub:publish':
+      await publishStubs(io)
+      return 0
+    case 'migrate':
+    case 'migrate:status':
+    case 'migrate:rollback':
+    case 'migrate:fresh':
+      return runMigrate(command, argv, io)
+    case 'db:seed': {
+      const dir = join(io.cwd, 'database/seeds')
+      const ran = await runSeeds(dir).catch(() => [])
+      writeln(io, ran.length === 0 ? 'No seeds.' : `Seeded ${ran.length} file(s).`)
+      return 0
+    }
+    case 'schema:pull': {
+      await mkdir(join(io.cwd, 'database'), { recursive: true })
+      await writeFile(
+        join(io.cwd, 'database/types.ts'),
+        `// Generated by \`reeve schema:pull\`. Do not edit.\nexport interface Database {}\n`,
+      )
+      writeln(io, 'database/types.ts')
+      return 0
+    }
+    case 'ward:list': {
+      const wards = await listDir(io, 'app/Wards')
+      const models = await listDir(io, 'app/Models')
+      writeln(io, `Models: ${models.join(', ') || '(none)'}`)
+      writeln(io, `Wards: ${wards.join(', ') || '(none)'}`)
+      return 0
+    }
+    case 'ward:check': {
+      const models = (await listDir(io, 'app/Models')).map((file) => file.replace(/\.ts$/, ''))
+      const wards = new Set(
+        (await listDir(io, 'app/Wards')).map((file) => file.replace(/\.ts$/, '')),
+      )
+      const missing = models.filter((model) => !wards.has(`${model}Ward`))
+      if (missing.length > 0) {
+        writeln(io, `Missing wards: ${missing.join(', ')}`)
+        return 1
+      }
+      writeln(io, 'Wards match models.')
+      return 0
+    }
+    case 'ward:sync':
+      writeln(io, 'Compile wards into a migration with the configured database driver.syncWards().')
+      return 0
+    case 'ward:explain': {
+      const model = operand(argv, 0)
+      const action = operand(argv, 1) ?? 'read'
+      writeln(io, `${model ?? 'Model'} ${action}: inspect app/Wards and the driver SQL compiler.`)
+      return 0
+    }
+    case 'route:list': {
+      await loadRoutes(io)
+      for (const route of Route.all()) {
+        writeln(
+          io,
+          `${route.method.padEnd(6)} ${route.path.padEnd(24)} ${route.name.padEnd(20)} ${route.controller.name}@${route.action} [${route.middleware.join(',')}]`,
+        )
+      }
+      if (Route.all().length === 0) writeln(io, 'No routes registered.')
+      return 0
+    }
+    case 'route:sync': {
+      await loadRoutes(io)
+      const adapter = new NextAdapter({ root: io.cwd })
+      const result = await adapter.mount(Route.manifest(), { kernel: createKernel() })
+      writeln(
+        io,
+        `Mounted ${result.mounted.length} route(s). Wrote ${result.generated.length} file(s).`,
+      )
+      return 0
+    }
+    case 'event:list':
+      writeln(
+        io,
+        'Events are registered through providers. Inspect app/Providers and app/Listeners.',
+      )
+      return 0
+    case 'config:show':
+      try {
+        const config = getConfig()
+        writeln(
+          io,
+          JSON.stringify({ name: config.name, drivers: Object.keys(config.drivers) }, null, 2),
+        )
+      } catch (error) {
+        writeln(io, error instanceof Error ? error.message : String(error))
+        return 1
+      }
+      return 0
+    case 'capabilities':
+      try {
+        writeln(io, JSON.stringify(capabilityMatrix(), null, 2))
+      } catch (error) {
+        writeln(io, error instanceof Error ? error.message : String(error))
+        return 1
+      }
+      return 0
+    case 'about': {
+      const bits = headerBits(io)
+      writeln(
+        io,
+        `Avelon reeve · ${bits.app} · ${bits.database} · ${bits.adapter} · ${bits.environment}`,
+      )
+      writeln(io, 'Packages: @avelonjs/cli @avelonjs/next @avelonjs/bailiff @avelonjs/assay @avelonjs/core')
+      return 0
+    }
+    case 'errand:work': {
+      const drained = await Errands.work()
+      writeln(io, `Drained ${String(drained)} errand(s).`)
+      return 0
+    }
+    case 'errand:failed': {
+      const failed = jobBoard().failed()
+      writeln(io, failed.length === 0 ? 'No failed errands.' : JSON.stringify(failed, null, 2))
+      return 0
+    }
+    case 'errand:retry': {
+      const id = operand(argv, 0)
+      if (id === undefined || id === 'all') {
+        for (const failed of jobBoard().failed()) jobBoard().retry(failed.id)
+        writeln(io, 'Retried all failed errands.')
+        return 0
+      }
+      jobBoard().retry(id)
+      writeln(io, `Retried ${id}.`)
+      return 0
+    }
+    case 'errand:flush':
+      jobBoard().flush()
+      resetErrands()
+      writeln(io, 'Flushed errands.')
+      return 0
+    case 'bailiff': {
+      const parsed = parseBailiffArgs(argv)
+      const result = await runBailiff({ ...parsed, cwd: io.cwd })
+      io.stdout.write(result.output)
+      return result.exitCode
+    }
+    case 'docs:check':
+      return runDocsCheck(argv, io)
+    case 'doctor':
+      return runDoctor(io)
+    case 'tinker':
+      return runTinker(argv, io)
+    default:
+      writeln(io, `Unknown command '${command}'.`)
+      return 1
+  }
+}
+
+async function runMigrate(command: string, argv: readonly string[], io: ReeveIO): Promise<number> {
+  const env = headerBits(io).environment
+  if (command === 'migrate:fresh' && env !== 'local' && io.confirm !== env) {
+    writeln(io, `Refusing migrate:fresh on ${env}. Pass the environment name as confirmation.`)
+    return 1
+  }
+  try {
+    if (command === 'migrate:status') writeln(io, JSON.stringify(await DB.status(), null, 2))
+    else if (command === 'migrate:rollback')
+      writeln(io, JSON.stringify(await DB.rollback(), null, 2))
+    else if (command === 'migrate:fresh') {
+      await DB.rollback(100).catch(() => undefined)
+      writeln(io, JSON.stringify(await DB.apply(), null, 2))
+      if (argv.includes('--seed')) await runCommand('db:seed', [], io)
+    } else writeln(io, JSON.stringify(await DB.apply(), null, 2))
+    return 0
+  } catch (error) {
+    writeln(io, error instanceof Error ? error.message : String(error))
+    return 1
+  }
+}
+
+async function runDoctor(io: ReeveIO): Promise<number> {
+  writeln(io, 'Doctor')
+  const bailiff = await runBailiff({ cwd: io.cwd, files: [io.cwd] })
+  writeln(
+    io,
+    bailiff.errorCount === 0 ? 'Bailiff: clean' : `Bailiff: ${bailiff.errorCount} error(s)`,
+  )
+  const wards = await runCommand('ward:check', [], io)
+  writeln(io, 'Types: run schema:pull and compare models in CI.')
+  writeln(io, `Env: ${headerBits(io).environment}`)
+  try {
+    writeln(io, 'Capabilities:')
+    writeln(io, JSON.stringify(capabilityMatrix(), null, 2))
+  } catch {
+    writeln(io, 'Capabilities: config is not defined.')
+  }
+  return bailiff.exitCode === 0 && wards === 0 ? 0 : 1
+}
+
+async function runTinker(argv: readonly string[], io: ReeveIO): Promise<number> {
+  const executeIndex = argv.indexOf('--execute')
+  const source = executeIndex >= 0 ? argv[executeIndex + 1] : undefined
+  if (source === undefined) {
+    writeln(
+      io,
+      'Tinker. Pass --execute "expression" in CI. Models, DB, and helpers preload in a TTY REPL.',
+    )
+    return 0
+  }
+  const result = (0, eval)(source)
+  writeln(io, String(await result))
+  return 0
+}
+
+export { flags }