rman 0.38.0 → 1.0.2

package/services/import.service.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { GitHelper } from '../utils/git.js';
+export var ImportService;
+(function (ImportService) {
+    /**
+     * Imports `sourcePath` (a local clone of some other git repository) as a new package under this
+     * repository, preserving its **entire commit history** - every original commit, author, date and
+     * message stays intact, just as if the package had always lived at its new path. Unlike copying
+     * the files over and making one "import" commit, `git blame`/`git log --follow` keep working on
+     * the imported files afterward.
+     *
+     * How: every commit reachable from `sourcePath`'s HEAD is turned into a patch (`git format-patch
+     * --root`, oldest first), each patch's file paths are rewritten to be prefixed with the new
+     * subdirectory, then replayed onto this repository via `git am` (preserving authorship). A
+     * source repo with merge commits or binary-file renames can still trip up a patch here or there -
+     * same caveat `lerna import` has, since both use this same replay approach rather than a real
+     * merge (which real `git subtree` would give, at the cost of far less predictable behavior
+     * across git versions - the reason this - and lerna - avoid it).
+     */
+    async function importRepo(repository, sourcePath, options = {}) {
+        const absSource = path.resolve(sourcePath);
+        if (!fs.existsSync(path.join(absSource, '.git'))) {
+            throw new Error(`"${sourcePath}" is not a git repository (no .git found) - clone it locally first`);
+        }
+        const name = resolveSourceName(absSource);
+        const dirName = name.includes('/') ? name.slice(name.lastIndexOf('/') + 1) : name;
+        const destDir = options.dest ?? 'packages';
+        const targetDir = path.join(repository.dirname, destDir, dirName);
+        if (fs.existsSync(targetDir)) {
+            throw new Error(`"${path.relative(repository.dirname, targetDir)}" already exists`);
+        }
+        const sourceGit = new GitHelper({ cwd: absSource });
+        const patchDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rman-import-'));
+        try {
+            const patches = await sourceGit.formatPatches(patchDir);
+            if (!patches.length)
+                throw new Error(`"${sourcePath}" has no commits to import`);
+            const relTargetDir = path.relative(repository.dirname, targetDir).split(path.sep).join('/');
+            for (const patchFile of patches)
+                rewritePatchPaths(patchFile, relTargetDir);
+            const targetGit = new GitHelper({ cwd: repository.dirname });
+            await targetGit.applyPatches(patches);
+            return { name, targetDir, commitCount: patches.length };
+        }
+        finally {
+            fs.rmSync(patchDir, { recursive: true, force: true });
+        }
+    }
+    ImportService.importRepo = importRepo;
+})(ImportService || (ImportService = {}));
+/** The source repo's own `package.json` name, or its directory's basename when it has none (or
+ *  isn't even a package yet - a plain library repo being folded in). */
+function resolveSourceName(absSource) {
+    const pkgJsonFile = path.join(absSource, 'package.json');
+    if (fs.existsSync(pkgJsonFile)) {
+        try {
+            const json = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf-8'));
+            if (typeof json.name === 'string' && json.name)
+                return json.name;
+        }
+        catch {
+            // malformed package.json - fall through to the directory name below.
+        }
+    }
+    return path.basename(absSource);
+}
+/**
+ * Rewrites a `git format-patch`-produced file in place so every path it touches is prefixed with
+ * `prefix` (the new subdirectory, forward-slash-separated) - `diff --git`/`---`/`+++`/rename
+ * headers only; `--- /dev/null`/`+++ /dev/null` (new/deleted file markers) never match, since they
+ * have no `a/`/`b/` prefix to rewrite in the first place.
+ */
+function rewritePatchPaths(patchFile, prefix) {
+    const content = fs.readFileSync(patchFile, 'utf-8');
+    const rewritten = content
+        .replace(/^diff --git a\/(.+?) b\/(.+)$/gm, (_m, a, b) => `diff --git a/${prefix}/${a} b/${prefix}/${b}`)
+        .replace(/^--- a\/(.+)$/gm, (_m, p) => `--- a/${prefix}/${p}`)
+        .replace(/^\+\+\+ b\/(.+)$/gm, (_m, p) => `+++ b/${prefix}/${p}`)
+        .replace(/^rename from (.+)$/gm, (_m, p) => `rename from ${prefix}/${p}`)
+        .replace(/^rename to (.+)$/gm, (_m, p) => `rename to ${prefix}/${p}`);
+    fs.writeFileSync(patchFile, rewritten);
+}

package/services/list.service.d.ts

@@ -0,0 +1,27 @@
+import type { Repository } from '../core/repository.js';
+import { type PackageFilterOptions } from '../utils/package-filter.js';
+export declare namespace ListService {
+    interface Options extends PackageFilterOptions {
+        /** Topological order (dependencies before dependents) instead of lexical by directory. */
+        toposort?: boolean;
+        /** Only include packages that have changed since the last publish (dirty or committed but
+         *  not yet published) - or, with `changedSince`, since that specific commit/hash. */
+        changed?: boolean;
+        changedSince?: string;
+    }
+    interface Item {
+        name: string;
+        version: string;
+        location: string;
+        private: boolean;
+        status: Repository.PackageStatus;
+        /** In-repo package names this one depends on - enough to build a dependency graph without a
+         *  second call, e.g. `Object.fromEntries(items.map(i => [i.name, i.dependencies]))`. */
+        dependencies: string[];
+    }
+    /** `list`: every package in the repository (or, with `changed`/`changedSince`, only the ones
+     *  that have actually changed), each with its version, location, private flag, and change
+     *  status relative to upstream. Pure data - no console output; `rman list`'s own command
+     *  decides how to present it (table, JSON, parseable, names only, or a dependency graph). */
+    function getPackages(repository: Repository, options?: Options): Promise<Item[]>;
+}

package/services/list.service.js

@@ -0,0 +1,25 @@
+import path from 'path';
+import { filterPackages } from '../utils/package-filter.js';
+export var ListService;
+(function (ListService) {
+    /** `list`: every package in the repository (or, with `changed`/`changedSince`, only the ones
+     *  that have actually changed), each with its version, location, private flag, and change
+     *  status relative to upstream. Pure data - no console output; `rman list`'s own command
+     *  decides how to present it (table, JSON, parseable, names only, or a dependency graph). */
+    async function getPackages(repository, options = {}) {
+        const packages = filterPackages(repository.getPackages({ toposort: options.toposort }), options);
+        const status = await repository.listStatus({ hash: options.changedSince });
+        let items = packages.map(p => ({
+            name: p.name,
+            version: p.version,
+            location: path.relative(repository.dirname, p.dirname) || '.',
+            private: p.isPrivate,
+            status: status[p.name],
+            dependencies: [...p.dependencies],
+        }));
+        if (options.changed || options.changedSince)
+            items = items.filter(it => it.status !== 'clean');
+        return items;
+    }
+    ListService.getPackages = getPackages;
+})(ListService || (ListService = {}));

package/services/publish.service.d.ts

@@ -0,0 +1,79 @@
+import type { Package } from '../core/package.js';
+import type { Repository } from '../core/repository.js';
+import { type PackageFilterOptions } from '../utils/package-filter.js';
+import { CiService } from './ci.service.js';
+export declare namespace PublishService {
+    /** Injectable registry lookup - mainly for tests, so they don't depend on network access or a
+     *  real published package. Same shape as `detectChangeHash`'s own `npmViewVersion`. */
+    interface Deps {
+        npmViewVersion?: (name: string, cwd: string) => Promise<string | undefined>;
+    }
+    interface Options extends PackageFilterOptions {
+        /** A package with uncommitted local changes is excluded (status `'skip'`) instead of aborting
+         *  the whole plan (status `'error'`) - same as `version`'s own option. Default false. */
+        ignoreDirty?: boolean;
+        /** Registry to check against (and, in `applyPlan`, publish to) - `.npmrc`'s own configured
+         *  registry is used when omitted. */
+        registry?: string;
+        /** Path to a custom `.npmrc`, for both the registry check and the actual publish. */
+        userconfig?: string;
+    }
+    interface ApplyOptions extends Options {
+        packageManager?: CiService.PackageManager;
+        /** `npm publish --access <access>` - required by the registry for a *new* scoped package. */
+        access?: 'public' | 'restricted';
+        /** `npm publish --tag <tag>` - the dist-tag this version is published under (default `latest`). */
+        tag?: string;
+        /** `npm publish --otp <otp>` - a 2FA one-time password, for registries that require it. */
+        otp?: string;
+        /** Subdirectory to publish from, relative to the package's own directory - only consulted when
+         *  the package doesn't already declare its own `package.json` `publishConfig.directory` (npm's
+         *  native mechanism for this, which always wins when present). */
+        contents?: string;
+    }
+    /** One package's outcome in a publish plan - see `getPlan`. */
+    interface Entry {
+        package: Package;
+        version: string;
+        status: 'publish' | 'skip' | 'up-to-date' | 'error';
+        /** What's currently on the registry, if anything - only set once a registry check actually ran. */
+        registryVersion?: string;
+        reason?: string;
+    }
+    /**
+     * Computes what `publish` *would* do, across every non-private package (topological order,
+     * dependencies before dependents) - never touches the registry to publish anything, just
+     * queries it to decide, so it's safe to call any time, including as the plan a bare `rman
+     * publish` shows before asking for confirmation.
+     *
+     * A `private: true` package is always `'skip'`ped outright. A package with uncommitted local
+     * changes is `'error'` (aborts the whole plan) unless `options.ignoreDirty` downgrades it to
+     * `'skip'` instead - same rule `version` uses, since publishing untracked local edits is worse
+     * than a bad commit. Otherwise, its currently-published registry version (via `npm view`,
+     * queried concurrently across every remaining package) decides the rest: identical to the local
+     * `package.json` version is `'up-to-date'`; anything else (including never having been
+     * published at all) is `'publish'`.
+     *
+     * Deliberately decoupled from `version`: this only ever looks at what's *currently* on disk and
+     * on the registry, never at whether `version` was just run - so it works equally well right
+     * after a version bump, or standing alone in a release pipeline that bumped days earlier.
+     *
+     * A monorepo's root package is never a candidate at all - `repository.getPackages()` already
+     * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
+     * where it's a normal candidate like any other).
+     */
+    function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
+    /**
+     * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
+     * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not
+     * concurrent: unlike `run`/`build`, a package genuinely needs its own dependencies to have
+     * landed on the registry first, and publishing is rare enough (once per release) that the
+     * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
+     *
+     * If a package fails, every other still-pending entry depending on it (transitively) is marked
+     * `'error'` too and never attempted - publishing a package whose own new dependency range points
+     * at a version that never actually reached the registry would hand consumers a broken install.
+     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
+     */
+    function applyPlan(repository: Repository, plan: Entry[], options?: ApplyOptions): Promise<Entry[]>;
+}

package/services/publish.service.js

@@ -0,0 +1,199 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { exec } from '../utils/exec.js';
+import { GitHelper } from '../utils/git.js';
+import { filterPackages } from '../utils/package-filter.js';
+import { parseWorkspaceRange, resolveWorkspaceRange } from '../utils/workspace-range.js';
+import { CiService } from './ci.service.js';
+import { DEPENDENCY_KEYS } from './version.service.js';
+export var PublishService;
+(function (PublishService) {
+    /**
+     * Computes what `publish` *would* do, across every non-private package (topological order,
+     * dependencies before dependents) - never touches the registry to publish anything, just
+     * queries it to decide, so it's safe to call any time, including as the plan a bare `rman
+     * publish` shows before asking for confirmation.
+     *
+     * A `private: true` package is always `'skip'`ped outright. A package with uncommitted local
+     * changes is `'error'` (aborts the whole plan) unless `options.ignoreDirty` downgrades it to
+     * `'skip'` instead - same rule `version` uses, since publishing untracked local edits is worse
+     * than a bad commit. Otherwise, its currently-published registry version (via `npm view`,
+     * queried concurrently across every remaining package) decides the rest: identical to the local
+     * `package.json` version is `'up-to-date'`; anything else (including never having been
+     * published at all) is `'publish'`.
+     *
+     * Deliberately decoupled from `version`: this only ever looks at what's *currently* on disk and
+     * on the registry, never at whether `version` was just run - so it works equally well right
+     * after a version bump, or standing alone in a release pipeline that bumped days earlier.
+     *
+     * A monorepo's root package is never a candidate at all - `repository.getPackages()` already
+     * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
+     * where it's a normal candidate like any other).
+     */
+    async function getPlan(repository, options = {}, deps = {}) {
+        const git = new GitHelper({ cwd: repository.dirname });
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options);
+        const dirtyFiles = await git.listDirtyFiles({ absolute: true });
+        const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
+        const npmViewVersion = deps.npmViewVersion ?? ((name, cwd) => defaultNpmViewVersion(name, cwd, options));
+        const entries = new Map();
+        const toCheck = [];
+        for (const pkg of packages) {
+            if (pkg.isPrivate) {
+                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
+            }
+            else if (isDirty(pkg)) {
+                entries.set(pkg.name, {
+                    package: pkg,
+                    version: pkg.version,
+                    status: options.ignoreDirty ? 'skip' : 'error',
+                    reason: 'uncommitted local changes',
+                });
+            }
+            else {
+                toCheck.push(pkg);
+            }
+        }
+        await Promise.all(toCheck.map(async (pkg) => {
+            const registryVersion = await npmViewVersion(pkg.name, pkg.dirname);
+            entries.set(pkg.name, {
+                package: pkg,
+                version: pkg.version,
+                registryVersion,
+                status: registryVersion === pkg.version ? 'up-to-date' : 'publish',
+                reason: registryVersion ? `registry has ${registryVersion}` : 'never published',
+            });
+        }));
+        return packages.map(pkg => entries.get(pkg.name));
+    }
+    PublishService.getPlan = getPlan;
+    /**
+     * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -
+     * see `getPlan`), via the configured `packageManager`'s own `publish` command. Sequential, not
+     * concurrent: unlike `run`/`build`, a package genuinely needs its own dependencies to have
+     * landed on the registry first, and publishing is rare enough (once per release) that the
+     * simplicity is worth more than the parallelism `run` gets from `power-tasks`.
+     *
+     * If a package fails, every other still-pending entry depending on it (transitively) is marked
+     * `'error'` too and never attempted - publishing a package whose own new dependency range points
+     * at a version that never actually reached the registry would hand consumers a broken install.
+     * A package's own failure doesn't stop unrelated packages elsewhere in the plan, though.
+     */
+    async function applyPlan(repository, plan, options = {}) {
+        const packageManager = CiService.resolvePackageManager(repository, options.packageManager);
+        const failed = new Set();
+        const result = [];
+        const packagesByName = new Map(repository.getPackages().map(p => [p.name, p]));
+        for (const entry of plan) {
+            if (entry.status !== 'publish') {
+                result.push(entry);
+                continue;
+            }
+            const pkg = entry.package;
+            const blocker = pkg.dependencies.find(d => failed.has(d));
+            if (blocker) {
+                failed.add(pkg.name);
+                result.push({ ...entry, status: 'error', reason: `dependency "${blocker}" failed to publish` });
+                continue;
+            }
+            const restore = rewriteWorkspaceRangesForPublish(pkg, packagesByName);
+            try {
+                await exec(buildPublishCommand(packageManager, options), {
+                    cwd: resolvePublishDir(pkg, options.contents),
+                    stdio: 'inherit',
+                });
+                result.push(entry);
+            }
+            catch (e) {
+                failed.add(pkg.name);
+                result.push({ ...entry, status: 'error', reason: e.message });
+            }
+            finally {
+                restore?.();
+            }
+        }
+        return result;
+    }
+    PublishService.applyPlan = applyPlan;
+})(PublishService || (PublishService = {}));
+const execFileAsync = promisify(execFile);
+/** `npm view <name> version`, optionally against a custom registry/`.npmrc` - `undefined` for any
+ *  failure (never published, no network, private/restricted with no access, ...), same
+ *  catch-everything shape as `change-hash.ts`'s own `defaultNpmViewVersion` (kept separate here
+ *  since this one also needs `--registry`/`--userconfig`, which that one has no use for). */
+async function defaultNpmViewVersion(name, cwd, options) {
+    const argv = ['view', name, 'version'];
+    if (options.registry)
+        argv.push('--registry', options.registry);
+    if (options.userconfig)
+        argv.push('--userconfig', options.userconfig);
+    try {
+        const { stdout } = await execFileAsync('npm', argv, { cwd });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** npm's own native `publishConfig.directory` (if the package declares one) always wins over
+ *  `options.contents` - the package's own package.json is the more authoritative, persistent
+ *  statement of "this is where the publishable output lives", `--contents` is just a fallback for
+ *  when it doesn't declare one at all. */
+function resolvePublishDir(pkg, contentsOverride) {
+    const native = pkg.json.publishConfig?.directory;
+    const rel = (typeof native === 'string' && native) || contentsOverride;
+    return rel ? path.resolve(pkg.dirname, rel) : pkg.dirname;
+}
+function buildPublishCommand(packageManager, options) {
+    const args = ['publish'];
+    if (options.access)
+        args.push('--access', options.access);
+    if (options.tag)
+        args.push('--tag', options.tag);
+    if (options.otp)
+        args.push('--otp', options.otp);
+    if (options.registry)
+        args.push('--registry', options.registry);
+    if (options.userconfig)
+        args.push('--userconfig', options.userconfig);
+    return `${packageManager} ${args.join(' ')}`;
+}
+/**
+ * Rewrites every `"workspace:"` dependency range in `pkg`'s `package.json` to a real,
+ * registry-publishable range (the same substitution pnpm/yarn's own publish performs - see
+ * `resolveWorkspaceRange`), just before shelling out to `npm publish` - which reads whatever is
+ * actually on disk, unlike pnpm/yarn's own publish this never packs into a staging tarball first.
+ * Returns a function that restores the file's original bytes (and `pkg`'s in-memory state)
+ * verbatim; always invoke it from a `finally`, so a failed publish never leaves a rewritten
+ * `package.json` behind. Returns `undefined` (nothing to restore, no disk write at all) when `pkg`
+ * has no `"workspace:"` ranges to begin with.
+ */
+function rewriteWorkspaceRangesForPublish(pkg, packagesByName) {
+    const hasWorkspaceRange = DEPENDENCY_KEYS.some(depKey => {
+        const deps = pkg.json[depKey];
+        return deps && Object.values(deps).some(v => parseWorkspaceRange(v));
+    });
+    if (!hasWorkspaceRange)
+        return undefined;
+    const original = fs.readFileSync(pkg.jsonFileName, 'utf-8');
+    for (const depKey of DEPENDENCY_KEYS) {
+        const deps = pkg.json[depKey];
+        if (!deps)
+            continue;
+        for (const depName of Object.keys(deps)) {
+            const parsed = parseWorkspaceRange(deps[depName]);
+            if (!parsed)
+                continue;
+            const depPkg = packagesByName.get(depName);
+            if (depPkg)
+                deps[depName] = resolveWorkspaceRange(parsed, depPkg.version);
+        }
+    }
+    pkg.writeJson();
+    return () => {
+        fs.writeFileSync(pkg.jsonFileName, original, 'utf-8');
+        pkg.reloadJson();
+    };
+}

package/services/run.service.d.ts

@@ -0,0 +1,99 @@
+import type { Package } from '../core/package.js';
+import type { Repository } from '../core/repository.js';
+import { type LogLevel } from '../utils/logger.js';
+import { type PackageFilterOptions } from '../utils/package-filter.js';
+export declare namespace RunService {
+    interface Options extends PackageFilterOptions {
+        /** Max packages built at once: `true`/omitted = CPU count, a number = that many, `false` = serial (1). */
+        parallel?: boolean | number;
+        /** Respect the package dependency graph: a package waits for its dependencies and is skipped
+         *  if one fails. Default true (right for `build`). Set false for scripts like `lint`/`test`
+         *  where packages are independent - order becomes alphabetical and one package's failure
+         *  (or its dependency's) never skips another. */
+        topo?: boolean;
+        bail?: boolean;
+        changed?: boolean;
+        changedSince?: string;
+        /** Show the live progress panel. Default true; auto-disabled when stdout isn't a TTY. */
+        progress?: boolean;
+        /** Verbosity of the classic per-step log (only applies when the live panel is off). Falls back to
+         *  the root's `.rmanrc logLevel`, then 'info' - see `resolveRootLogLevel`. */
+        logLevel?: LogLevel;
+        /** Run across the whole repository even when the current directory is inside a single package
+         *  (which otherwise scopes the run to just that package, and skips the root's own pre/post
+         *  bookend - see `Repository.currentPackage`). Has no effect when already at the repository
+         *  root, or outside any known package. */
+        root?: boolean;
+    }
+    /**
+     * A package's `.rmanrc` (cascaded) can configure `run.<script>.*` - e.g.
+     *   run:
+     *     build:
+     *       concurrency: 2
+     *     lint:
+     *       topo: false
+     *       bail: false
+     * and a package can opt itself out of a script entirely:
+     *   run:
+     *     build:
+     *       skip: true
+     * or supply the command(s) to run when its own package.json doesn't define this script (or its
+     * pre/post hooks) at all - a single string, or an array to run several in sequence - see
+     * `getScriptSteps`:
+     *   run:
+     *     build:
+     *       script: tsc -b
+     *       preScript: [node ./generate.js, node ./validate.js]
+     *       postScript: node ./copy-assets.js
+     *       override: true   # use these even if the package *does* define its own
+     */
+    function getConfig(pkg: Package, script: string): Record<string, unknown>;
+    /**
+     * `.rmanrc` conditional execution, GitHub Actions-`if`-flavored but a small closed grammar
+     * instead of a full expression language (less to get wrong, still covers what's asked for) -
+     * atoms combined with `and`/`or` (`and` binds tighter, same as most languages) and `(...)`:
+     *
+     *   run:
+     *     build:
+     *       if: changed                                    # changed since the last publish
+     *     test:
+     *       if: changed = a1b2c3d                           # changed since a specific commit
+     *       if: changed = {CHANGE_HASH}                     # {NAME} -> process.env.NAME first
+     *       if: (changed or dirty) and not committed
+     */
+    type IfNode = {
+        kind: 'atom';
+        name: string;
+        value?: string;
+    } | {
+        kind: 'not';
+        node: IfNode;
+    } | {
+        kind: 'and';
+        left: IfNode;
+        right: IfNode;
+    } | {
+        kind: 'or';
+        left: IfNode;
+        right: IfNode;
+    };
+    /** Recursive-descent parser over `tokenizeIf`'s output: expr := or ; or := and ('or' and)* ;
+     *  and := unary ('and' unary)* ; unary := 'not' unary | GROUP | NAME ['=' VALUE] */
+    function parseIfExpr(raw: unknown): IfNode | undefined;
+    /** Evaluates a parsed `if` expression for one package. `statusCache` avoids repeat `git` calls
+     *  for the same reference hash across packages/scripts in a single run. */
+    function evaluateIf(repository: Repository, pkg: Package, node: IfNode, statusCache: Map<string, Record<string, Repository.PackageStatus>>): Promise<boolean>;
+    function runScript(repository: Repository, script: string, options?: Options & {
+        commandName?: string;
+    }): Promise<void>;
+}
+/** Resolution order: explicit CLI flag > the package's resolved `.rmanrc` > `fallback`. */
+export declare function resolveBool(cliValue: boolean | undefined, pkg: Package, script: string, key: string, fallback: boolean): boolean;
+/**
+ * Bail is the one setting where a package's own `.rmanrc` outranks even an explicit CLI flag:
+ * "this package's failure must always stop the batch" is a more specific, intentional statement
+ * than a broad `--no-bail` meant for the run as a whole, and shouldn't be silently overridable by it.
+ */
+export declare function resolveBail(cliValue: boolean | undefined, pkg: Package, script: string, fallback: boolean): boolean;
+export declare function resolveNumber(cliValue: number | undefined, pkg: Package, script: string, key: string, fallback: number): number;
+export declare function resolveLogLevel(cliValue: LogLevel | undefined, pkg: Package, script: string, fallback: LogLevel): LogLevel;