diff --git a/.agents/config.jsonc b/.agents/config.jsonc index e29e4f5b..9ab07877 100644 --- a/.agents/config.jsonc +++ b/.agents/config.jsonc @@ -76,7 +76,7 @@ "ci": { "local": { "cloudOnly": { - "release.yml": "publishes @lntt/create to npm with the OIDC token of a published GitHub Release", + "release.yml": "publishes the @lntt packages to npm with the OIDC token of a published GitHub Release", "candidate.yml": "moves pull requests and edits the candidate with the GitHub App's token" } } diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 12ba30e9..c91a021d 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -4,7 +4,8 @@ name: Release the @lntt packages # gh release create vX.Y.Z --generate-notes # Every published package under packages/ shares one version, and the tag must match # it (docs/process/delivery.md). A release marked as pre-release is a dry run: every -# check runs and `npm publish --dry-run` packs each package, nothing reaches npm. +# check runs, pnpm packs each package and `npm publish --dry-run` reads the +# tarball, nothing reaches npm. on: release: types: [published] @@ -46,13 +47,16 @@ jobs: SCAFFOLD_SMOKE: '1' # Auth is OIDC via the trusted publisher configured on npmjs.com for each - # package, this repo and this workflow: no NPM_TOKEN secret. `prepack` builds - # what ships compiled (docs/adr/cli-runtime-and-publishing.md); --provenance is - # automatic under trusted publishing. A version already on npm is skipped, so a - # run that failed half-way can be re-run. + # package, this repo and this workflow: no NPM_TOKEN secret. Each package is + # packed by pnpm, which runs `prepack` (it builds what ships compiled) and applies + # publishConfig's `bin` and `exports`, pointing a package the repo runs from + # source at dist/ (docs/adr/cli-runtime-and-publishing.md); npm publishes the + # tarball. --provenance is automatic under trusted publishing. A version already + # on npm is skipped, so a run that failed half-way can be re-run. - name: Publish run: | VERSION="${GITHUB_REF_NAME#v}" + tarballs="$RUNNER_TEMP/tarballs" # On its own line: a failing list inside `for … in $(…)` would publish # nothing and leave the step green. dirs="$(node scripts/packages-version.mts list)" @@ -62,6 +66,9 @@ jobs: echo "$name@$VERSION is already on npm: skipped" continue fi + rm -rf "$tarballs" && mkdir -p "$tarballs" + (cd "$dir" && pnpm pack --pack-destination "$tarballs") + # An absolute path: npm reads a bare file name as a git spec. # shellcheck disable=SC2086 # DRY_RUN holds several flags, or none - (cd "$dir" && npm publish --provenance --access public $DRY_RUN) + npm publish "$(ls "$tarballs"/*.tgz)" --provenance --access public $DRY_RUN done diff --git a/README.md b/README.md index b726952c..f86bff78 100644 --- a/README.md +++ b/README.md @@ -52,8 +52,9 @@ it by itself in a folder it already trusts. What every project must keep current lives in `packages/`, to be published by the release flow and consumed by version: `@lntt/biome-config`, `@lntt/typescript-config`, -`@lntt/stylelint-config`, `@lntt/playwright-config`, `@lntt/test-utils`. The CLI never -rewrites the `@lntt` scope ([scaffolding contract](./docs/adr/scaffolding-contract.md)). +`@lntt/stylelint-config`, `@lntt/playwright-config`, `@lntt/test-utils`, and the +`lntt` command, `@lntt/lntt`. The CLI never rewrites the `@lntt` scope +([scaffolding contract](./docs/adr/scaffolding-contract.md)). Each package's README says how a project installs and uses it. ## Develop diff --git a/docs/adr/cli-runtime-and-publishing.md b/docs/adr/cli-runtime-and-publishing.md index 0d4a045a..df4be1e1 100644 --- a/docs/adr/cli-runtime-and-publishing.md +++ b/docs/adr/cli-runtime-and-publishing.md @@ -47,16 +47,24 @@ it ships: The packages published from `packages/` besides the CLI follow the same rule. -- **A package whose code Node runs** (`@lntt/playwright-config`, `@lntt/test-utils`) - is authored in TypeScript and published compiled: `tsconfig.build.json` emits - `src/` to `dist/` with declarations, `exports` and `bin` point at `dist/`, - `prepack` builds, `files` ships `dist`. Its tests import the sources, and at least - one imports it by name from a `node_modules`, built. +- **A package whose code Node runs** (`@lntt/playwright-config`, `@lntt/test-utils`, + `@lntt/lntt`) is authored in TypeScript and published compiled: `tsconfig.build.json` + emits its sources to `dist/` with declarations, the published `exports` and `bin` + point at `dist/`, `prepack` builds, `files` ships `dist`. Files its code reads at run + time ship next to it (`@lntt/lntt` copies `agents/` to `dist/agents`). Its tests + import the sources, and at least one imports it by name from a `node_modules`, built. +- **A package this repo runs from source through the workspace** (`@lntt/lntt`: the + root's `lntt`, the git hooks, `commitlint.config.mjs`, the CI workflows) keeps + `bin` and `exports` on its `.ts` sources and declares the published ones, on + `dist/`, in `publishConfig`. pnpm applies those overrides when it packs; npm does + not, so the release packs every package with `pnpm pack` and publishes the tarball + with `npm publish`. - **A config package** (`@lntt/biome-config`, `@lntt/typescript-config`, `@lntt/stylelint-config`) ships its files as they are, listed in `files` and `exports`. - **The tool a package configures is a peer dependency** (`@biomejs/biome`, - `typescript`, `stylelint`, `@playwright/test`): the project installs it once, at + `typescript`, `stylelint`, `@playwright/test`, `@commitlint/config-conventional` + for `@lntt/lntt`'s commitlint configuration): the project installs it once, at the version it chooses within the range. - **Tests consume a package by its published name** from a `node_modules`, the way a project does. The scaffold smoke installs every published package from its @@ -76,8 +84,8 @@ the whole set, which the template depends on as one. - **Publishing is CI only**, from `.github/workflows/release.yml`, through npm OIDC trusted publishing (`--provenance`, no npm token). A version already on npm is skipped, so a failed run can be re-run. -- **A release marked as pre-release is a dry run**: every check, then - `npm publish --dry-run`; nothing reaches npm. +- **A release marked as pre-release is a dry run**: every check runs and nothing + reaches npm. - **The one exception: a new package's first publish is by hand**, once, as a `0.0.0` placeholder. npm configures a trusted publisher only on a package that already exists (npm/cli#8544); the placeholder exists so the first CI release can @@ -149,6 +157,13 @@ written for the projects; the divergence is intentional. tool too, to run it; two declared copies at different versions mean two runners (Playwright refuses a second `@playwright/test`) or a config validated against a tool the project does not run. +- **`bin` and `exports` on `dist/` in the manifest itself**, for a package the repo + runs from source. Every in-repo use (the git hooks, commitlint, `pnpm exec lntt` + in CI) would need a build first, and a stale `dist/` would run instead of the code + under review. +- **`npm publish` of the package directory.** npm ignores `publishConfig.bin` and + `publishConfig.exports`, so it would publish the source entries, which fail under + `node_modules`. - **A token for the first publish of a new package** (an npm automation token as a repository secret, used once by the workflow). It puts a long-lived publish token in the repository for a step that happens once per package, and npm still needs diff --git a/docs/process/delivery.md b/docs/process/delivery.md index 6d14aa98..6d412983 100644 --- a/docs/process/delivery.md +++ b/docs/process/delivery.md @@ -216,12 +216,14 @@ ends. Publishing the GitHub Release starts `.github/workflows/release.yml`: it checks that the tag is every package's version, runs lint, typecheck and the tests with the scaffold smoke, and publishes each package through npm trusted publishing (OIDC, -`--provenance`, no npm token), skipping a version npm already has. +`--provenance`, no npm token), skipping a version npm already has. Each package is +packed with `pnpm pack`, so its `publishConfig` applies, and npm publishes the tarball. **A dry run** is a pre-release: set a pre-release version on a branch (`node scripts/packages-version.mts set X.Y.Z-rc.N`, commit, push), then `gh release create vX.Y.Z-rc.N --prerelease --target `. The workflow runs every -check and `npm publish --dry-run`; nothing reaches npm. Delete the pre-release, its +check, packs each package and passes the tarball to `npm publish --dry-run`; nothing +reaches npm. Delete the pre-release, its tag and the branch afterwards. Promoting a pre-release to a full release publishes nothing: the promotion fires @@ -233,6 +235,10 @@ because npm configures a trusted publisher only on a package that exists: 1. Publish a `0.0.0` placeholder from the package directory, logged in to npm with publish rights on the `@lntt` scope: `npm version 0.0.0 --no-git-tag-version && npm publish --access public && git checkout package.json`. + The placeholder only reserves the name and is never installed: published from the + directory, npm ignores `publishConfig.bin` and `publishConfig.exports`, so a package + that points its published `bin` and `exports` at `dist/` there ships its source + entries in the placeholder. It is the only publish ever made from a machine ([CLI runtime and publishing](../adr/cli-runtime-and-publishing.md)); the version set by the release bump is untouched. diff --git a/packages/create/test/scaffold-smoke.test.ts b/packages/create/test/scaffold-smoke.test.ts index e6685a22..1e630bb7 100644 --- a/packages/create/test/scaffold-smoke.test.ts +++ b/packages/create/test/scaffold-smoke.test.ts @@ -138,6 +138,16 @@ const adopt: Record void> = { assert.equal(execFileSync('node', [probe], { cwd: app, encoding: 'utf8' }).trim(), 'http://localhost:4321') rmSync(probe) }, + // The command the project's tooling and the plugin's skills call: the installed bin + // reads the configuration the scaffolder wrote. + '@lntt/lntt': () => { + const lntt = join(app, 'node_modules/.bin/lntt') + run(lntt, ['--help'], app) + assert.equal( + execFileSync(lntt, ['get', 'lunette.template'], { cwd: app, encoding: 'utf8' }).trim(), + '"react-router"', + ) + }, } // The packages a generated project installs from npm, installed here from the diff --git a/packages/lntt/LICENSE b/packages/lntt/LICENSE new file mode 100644 index 00000000..f686ce4d --- /dev/null +++ b/packages/lntt/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Lunette + +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. diff --git a/packages/lntt/README.md b/packages/lntt/README.md index b26139b1..ec967a69 100644 --- a/packages/lntt/README.md +++ b/packages/lntt/README.md @@ -464,5 +464,14 @@ CircleCI projects need the `circleci` CLI; container mode needs Docker and `act` ## Requirements -Node ≥ 24. The package is private and runs from source until it is published with the -other shared packages. +Node ≥ 24. A project installs it as a development dependency, with +`@commitlint/config-conventional` as a peer when its commitlint configuration uses +`commitlintConfig`: + +```sh +pnpm add -D @lntt/lntt @commitlint/config-conventional +``` + +The configuration's `$schema` can point at the installed schema, +`node_modules/@lntt/lntt/schema/config.schema.json`. In the starter the package runs +from its sources through the workspace; the published package is compiled to `dist/`. diff --git a/packages/lntt/package.json b/packages/lntt/package.json index 80b5faa9..c50c9471 100644 --- a/packages/lntt/package.json +++ b/packages/lntt/package.json @@ -1,10 +1,16 @@ { "name": "@lntt/lntt", - "version": "0.0.0", - "private": true, + "version": "0.6.1", "description": "The lntt command: a Lunette project's configuration and operator profile, the managed block of AGENTS.md, the checks and reviews of a change, and its CI run on the local machine with the candidate automation", "type": "module", "license": "MIT", + "repository": { + "type": "git", + "url": "git+https://github.com/LunetteOrg/starter.git", + "directory": "packages/lntt" + }, + "homepage": "https://github.com/LunetteOrg/starter/tree/main/packages/lntt#readme", + "bugs": "https://github.com/LunetteOrg/starter/issues", "exports": { ".": "./src/index.ts", "./ci": "./src/ci/index.ts", @@ -14,13 +20,37 @@ "bin": { "lntt": "bin/lntt.ts" }, + "files": [ + "dist", + "schema" + ], "scripts": { + "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && node -e \"require('node:fs').cpSync('agents','dist/agents',{recursive:true})\"", + "prepack": "pnpm run build", "test": "node --test test/*.test.ts test/ci/*.test.ts", "typecheck": "tsc --noEmit" }, "engines": { "node": ">=24" }, + "publishConfig": { + "access": "public", + "bin": { + "lntt": "dist/bin/lntt.js" + }, + "exports": { + ".": { + "types": "./dist/src/index.d.ts", + "default": "./dist/src/index.js" + }, + "./ci": { + "types": "./dist/src/ci/index.d.ts", + "default": "./dist/src/ci/index.js" + }, + "./schema.json": "./schema/config.schema.json", + "./operator-schema.json": "./schema/operator.schema.json" + } + }, "dependencies": { "@actions/expressions": "0.3.61", "@actions/workflow-parser": "0.3.61", @@ -28,6 +58,14 @@ "jsonc-parser": "^3.3.1", "yaml": "^2.9.1" }, + "peerDependencies": { + "@commitlint/config-conventional": "^21.2.0" + }, + "peerDependenciesMeta": { + "@commitlint/config-conventional": { + "optional": true + } + }, "devDependencies": { "@commitlint/config-conventional": "^21.2.0", "@commitlint/lint": "^21.2.0", diff --git a/packages/lntt/src/cli.ts b/packages/lntt/src/cli.ts index 86992e6d..8f95e22b 100644 --- a/packages/lntt/src/cli.ts +++ b/packages/lntt/src/cli.ts @@ -45,6 +45,12 @@ export function main(args: string[]): void { function run(command: string | undefined, key: string | undefined, raw: string | undefined): void { switch (command) { + // Asked for, the usage is the answer: stdout, exit 0 (`npx @lntt/lntt --help`). + case '--help': + case '-h': + case 'help': + stdout.write(`${USAGE}\n`) + break case 'path': stdout.write(`${findConfig(cwd()).path}\n`) break diff --git a/packages/lntt/test/config.test.ts b/packages/lntt/test/config.test.ts index d0fa9cf2..a58e12a6 100644 --- a/packages/lntt/test/config.test.ts +++ b/packages/lntt/test/config.test.ts @@ -167,6 +167,14 @@ describe('the command line', () => { test('a usage error exits 2', () => { assert.equal(spawnSync('node', [BIN, 'frobnicate'], { cwd: root }).status, 2) }) + + for (const ask of ['--help', '-h', 'help']) { + test(`${ask} prints the usage on stdout and exits 0, with no configuration`, () => { + const run = spawnSync('node', [BIN, ask], { cwd: root, encoding: 'utf8' }) + assert.equal(run.status, 0) + assert.match(run.stdout, /^usage: lntt /) + }) + } }) describe('the local section', () => { diff --git a/packages/lntt/test/installed-bin.test.ts b/packages/lntt/test/installed-bin.test.ts new file mode 100644 index 00000000..7967f195 --- /dev/null +++ b/packages/lntt/test/installed-bin.test.ts @@ -0,0 +1,136 @@ +import assert from 'node:assert/strict' +import { execFileSync } from 'node:child_process' +import { + existsSync, + mkdirSync, + mkdtempSync, + readFileSync, + realpathSync, + rmSync, + symlinkSync, + writeFileSync, +} from 'node:fs' +import { tmpdir } from 'node:os' +import { dirname, join, resolve } from 'node:path' +import { after, before, describe, test } from 'node:test' +import { fileURLToPath } from 'node:url' + +const PKG_DIR = resolve(dirname(fileURLToPath(import.meta.url)), '..') + +// The package as a project installs it: packed, extracted into a real +// node_modules/@lntt/lntt, run from there. Node refuses to strip TypeScript types under +// node_modules, so what runs from source in this repo must ship compiled. The pack is +// `pnpm pack`, as in release.yml: only pnpm applies the publishConfig overrides that +// point `bin` and `exports` at dist/; `npm pack` would ship the source entries. +let tarball: string +let files: string[] +let project: string +let pkgRoot: string +let bin: string + +const tmps: string[] = [] +const mktmp = (prefix: string): string => { + const d = realpathSync(mkdtempSync(join(tmpdir(), prefix))) + tmps.push(d) + return d +} + +before(() => { + const packDir = mktmp('lntt-pack-') + // Piped, not ignored: a failing build shows its output in the thrown error. + execFileSync('pnpm', ['pack', '--pack-destination', packDir], { cwd: PKG_DIR, stdio: 'pipe' }) + tarball = join(packDir, `lntt-lntt-${JSON.parse(readFileSync(join(PKG_DIR, 'package.json'), 'utf8')).version}.tgz`) + files = execFileSync('tar', ['-tzf', tarball], { encoding: 'utf8' }).trim().split('\n') + + project = mktmp('lntt-installed-') + pkgRoot = join(project, 'node_modules', '@lntt', 'lntt') + mkdirSync(pkgRoot, { recursive: true }) + // tar strips the leading `package/` dir so the tarball lands directly in pkgRoot. + execFileSync('tar', ['-xzf', tarball, '-C', pkgRoot, '--strip-components=1']) + // The run-time dependencies, from this package's own install: no network. + symlinkSync(join(PKG_DIR, 'node_modules'), join(pkgRoot, 'node_modules'), 'dir') + + mkdirSync(join(project, '.agents')) + writeFileSync( + join(project, '.agents/config.jsonc'), + '{\n // a comment\n "recording": { "language": "en", "logs": {} }\n}\n', + ) + bin = join(pkgRoot, JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')).bin.lntt) +}) + +after(() => { + for (const d of tmps) rmSync(d, { recursive: true, force: true }) +}) + +describe('the installed package', () => { + test('ships JavaScript, with no TypeScript source besides declarations', () => { + const sources = files.filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts')) + assert.deepEqual(sources, []) + assert.ok(files.includes('package/schema/config.schema.json'), 'the schema a project points $schema at') + assert.ok(files.includes('package/schema/operator.schema.json'), 'the operator schema') + assert.ok(files.includes('package/dist/agents/block.md'), 'the agents/ files the code reads from dist/') + }) + + test('its bin points into dist and exists', () => { + assert.match(bin, /\/dist\/bin\/lntt\.js$/) + assert.ok(existsSync(bin)) + }) + + test('every bin and exports target of the packed manifest is in the package', () => { + const targets = (entry: unknown): string[] => + typeof entry === 'string' ? [entry] : Object.values(entry as object).flatMap(targets) + const manifest = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')) + const all = [...targets(manifest.bin), ...targets(manifest.exports)] + for (const entry of ['.', './ci']) { + assert.match(manifest.exports[entry].types, /\.d\.ts$/, `${entry} has its types condition`) + } + for (const target of all) assert.ok(existsSync(join(pkgRoot, target)), `${target} is packed`) + }) + + test('the commitlint peer is optional: lntt alone needs nothing more', () => { + const manifest = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf8')) + assert.ok(manifest.peerDependencies['@commitlint/config-conventional']) + assert.equal(manifest.peerDependenciesMeta['@commitlint/config-conventional'].optional, true) + }) + + for (const ask of ['--help', '-h', 'help']) { + test(`lntt ${ask} runs from inside node_modules`, () => { + assert.match(execFileSync('node', [bin, ask], { cwd: project, encoding: 'utf8' }), /^usage: lntt /) + }) + } + + test('lntt get reads the project configuration', () => { + const out = execFileSync('node', [bin, 'get', 'recording.language'], { cwd: project, encoding: 'utf8' }) + assert.equal(JSON.parse(out), 'en') + }) + + test('lntt sync writes the managed block from the agents/ files the package ships', () => { + execFileSync('node', [bin, 'sync'], { cwd: project }) + const agents = readFileSync(join(project, 'AGENTS.md'), 'utf8') + const source = readFileSync(join(PKG_DIR, 'agents/block.md'), 'utf8').trimEnd() + assert.ok(agents.includes(source), 'AGENTS.md holds agents/block.md') + }) + + test('a project imports the package, its ci entry and its schemas by name', () => { + const script = [ + "import { commitlintConfig } from '@lntt/lntt'", + "import { localAction } from '@lntt/lntt/ci'", + "import { createRequire } from 'node:module'", + 'const require = createRequire(import.meta.url)', + 'console.log(JSON.stringify({', + ' extends: commitlintConfig(process.cwd()).extends,', + ' ci: typeof localAction,', + " config: require('@lntt/lntt/schema.json').$id,", + " operator: require('@lntt/lntt/operator-schema.json').$id,", + '}))', + ].join('\n') + const out = execFileSync('node', ['--input-type=module', '-e', script], { cwd: project, encoding: 'utf8' }) + const id = (name: string): string => JSON.parse(readFileSync(join(PKG_DIR, 'schema', name), 'utf8')).$id + assert.deepEqual(JSON.parse(out), { + extends: ['@commitlint/config-conventional'], + ci: 'function', + config: id('config.schema.json'), + operator: id('operator.schema.json'), + }) + }) +}) diff --git a/packages/lntt/tsconfig.build.json b/packages/lntt/tsconfig.build.json new file mode 100644 index 00000000..77beffe0 --- /dev/null +++ b/packages/lntt/tsconfig.build.json @@ -0,0 +1,17 @@ +{ + // Emit config for the PUBLISHED artifact (docs/adr/cli-runtime-and-publishing.md). + // Node refuses to strip TypeScript types under node_modules, so the package ships + // bin/ and src/ compiled to dist/ with declarations; the schemas the sources import + // are copied to dist/schema by tsc. In this repo the sources run directly. + "extends": "./tsconfig.json", + "compilerOptions": { + "noEmit": false, + "allowImportingTsExtensions": false, + "rewriteRelativeImportExtensions": true, + "declaration": true, + "rootDir": ".", + "outDir": "dist" + }, + "include": ["src/**/*.ts", "bin/**/*.ts"], + "exclude": [] +} diff --git a/scripts/packages-version.test.mts b/scripts/packages-version.test.mts index 19c2407c..f0073f01 100644 --- a/scripts/packages-version.test.mts +++ b/scripts/packages-version.test.mts @@ -35,7 +35,7 @@ test('list names the published packages, the CLI last, never a private one', () ['@lntt/create', '1.0.0'], ['@lntt/test-utils', '1.0.0'], ['@lntt/biome-config', '1.0.0'], - ['@lntt/lntt', '0.0.0', true], + ['@lntt/internal', '0.0.0', true], ]) const r = run('list') assert.equal(r.status, 0, r.out) @@ -46,7 +46,7 @@ test('check passes when every published package has one version, and the tag mat repo([ ['@lntt/create', '1.2.0'], ['@lntt/biome-config', '1.2.0'], - ['@lntt/lntt', '0.0.0', true], + ['@lntt/internal', '0.0.0', true], ]) assert.equal(run('check').status, 0) assert.equal(run('check', '1.2.0').status, 0) @@ -76,11 +76,14 @@ test('set writes one version into every published package and leaves private one repo([ ['@lntt/create', '1.2.0'], ['@lntt/biome-config', '1.1.0'], - ['@lntt/lntt', '0.0.0', true], + ['@lntt/internal', '0.0.0', true], ]) const r = run('set', '1.3.0-rc.0') assert.equal(r.status, 0, r.out) - assert.deepEqual([version('create'), version('biome-config'), version('lntt')], ['1.3.0-rc.0', '1.3.0-rc.0', '0.0.0']) + assert.deepEqual( + [version('create'), version('biome-config'), version('internal')], + ['1.3.0-rc.0', '1.3.0-rc.0', '0.0.0'], + ) assert.equal(run('check', '1.3.0-rc.0').status, 0) })