@tallyrelease/cli 0.0.0-stage → 0.1.0-beta.1

package/dist/forge/forge.d.ts

@@ -0,0 +1,12 @@
+export interface WorkflowRunQuery {
+    owner: string;
+    repo: string;
+    /** Workflow file name, for example `ci.yaml`. */
+    workflow: string;
+    branch: string;
+}
+/** Code host API used by the cli. */
+export interface Forge {
+    /** Head shas of successful push runs of a workflow on a branch, newest first. */
+    lastSuccessfulPushRuns: (query: WorkflowRunQuery) => Promise<string[]>;
+}

package/dist/forge/forge.js

@@ -0,0 +1 @@
+export {};

package/dist/forge/github.d.ts

@@ -0,0 +1,8 @@
+import type { Forge } from "./forge.js";
+export interface GithubForgeOptions {
+    token: string;
+    /** `GITHUB_API_URL`, defaults to the public API. */
+    baseUrl?: string | undefined;
+}
+/** `Forge` backed by the GitHub REST API. */
+export declare const githubForge: (opts: GithubForgeOptions) => Forge;

package/dist/forge/github.js

@@ -0,0 +1,31 @@
+import { Octokit } from "@octokit/rest";
+/** `Forge` backed by the GitHub REST API. */
+export const githubForge = (opts) => {
+    const octokit = new Octokit({
+        auth: opts.token,
+        baseUrl: opts.baseUrl ?? "https://api.github.com",
+    });
+    return {
+        lastSuccessfulPushRuns: async ({ owner, repo, workflow, branch }) => {
+            try {
+                const { data } = await octokit.rest.actions.listWorkflowRuns({
+                    owner,
+                    repo,
+                    workflow_id: workflow,
+                    branch,
+                    status: "success",
+                    event: "push",
+                    per_page: 100,
+                });
+                return data.workflow_runs.map((run) => run.head_sha);
+            }
+            catch (error) {
+                // A renamed or deleted workflow has no runs to build on.
+                if (error.status === 404) {
+                    return [];
+                }
+                throw error;
+            }
+        },
+    };
+};

package/dist/fs-ctx.d.ts

@@ -0,0 +1,3 @@
+import type { ReadonlyFs } from "@tallyrelease/core";
+/** `ReadonlyFs` over the directory `root`. */
+export declare const nodeFs: (root: string) => ReadonlyFs;

package/dist/fs-ctx.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { globSync } from "tinyglobby";
+const IGNORED = ["**/.git/**", "**/node_modules/**", "vendor/**"];
+/** `ReadonlyFs` over the directory `root`. */
+export const nodeFs = (root) => ({
+    read: (path) => {
+        try {
+            return readFileSync(join(root, path), "utf8");
+        }
+        catch {
+            return undefined;
+        }
+    },
+    exists: (path) => existsSync(join(root, path)),
+    glob: (patterns, opts) => globSync(patterns, {
+        cwd: root,
+        dot: true,
+        ignore: IGNORED,
+        expandDirectories: false,
+        onlyDirectories: opts?.dirs ?? false,
+    })
+        .map((p) => p.replace(/\/$/, ""))
+        .sort(),
+});

package/dist/git/exec.d.ts

@@ -0,0 +1,9 @@
+export interface GitResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/** Runs `git` in `cwd`; resolves with the exit code instead of rejecting. */
+export declare const git: (cwd: string, args: readonly string[], debug?: (message: string) => void) => Promise<GitResult>;
+/** Runs `git` and returns stdout; throws on a non-zero exit code. */
+export declare const gitOk: (cwd: string, args: readonly string[], debug?: (message: string) => void) => Promise<string>;

package/dist/git/exec.js

@@ -0,0 +1,26 @@
+import { execFile } from "node:child_process";
+/** Runs `git` in `cwd`; resolves with the exit code instead of rejecting. */
+export const git = (cwd, args, debug) => {
+    debug?.(`git ${args.join(" ")}`);
+    return new Promise((resolve, reject) => {
+        execFile("git", ["-c", "core.quotePath=false", ...args], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error === null) {
+                resolve({ code: 0, stdout, stderr });
+            }
+            else if (typeof error.code === "number") {
+                resolve({ code: error.code, stdout, stderr });
+            }
+            else {
+                reject(new Error(error.message, { cause: error }));
+            }
+        });
+    });
+};
+/** Runs `git` and returns stdout; throws on a non-zero exit code. */
+export const gitOk = async (cwd, args, debug) => {
+    const result = await git(cwd, args, debug);
+    if (result.code !== 0) {
+        throw new Error(`git ${args.join(" ")} failed (${String(result.code)}): ${result.stderr.trim()}`);
+    }
+    return result.stdout;
+};

package/dist/git/reader.d.ts

@@ -0,0 +1,13 @@
+import type { GitReader, MaybePromise } from "@tallyrelease/core";
+/** `GitReader` plus the queries the cli needs to resolve a build base. */
+export interface RepoGit extends GitReader {
+    /** Full commit sha of `ref`, undefined if it does not resolve locally. */
+    resolve: (ref: string) => MaybePromise<string | undefined>;
+    /** Best common ancestor, undefined if none. */
+    mergeBase: (a: string, b: string) => MaybePromise<string | undefined>;
+    isShallow: () => MaybePromise<boolean>;
+    /** Current branch, undefined when detached. */
+    branch: () => MaybePromise<string | undefined>;
+}
+/** `RepoGit` backed by the `git` executable in `cwd`. */
+export declare const gitReader: (cwd: string, debug?: (message: string) => void) => RepoGit;

package/dist/git/reader.js

@@ -0,0 +1,114 @@
+import { gitOk, git as run } from "./exec.js";
+const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+const lines = (out) => out.split("\n").filter((l) => l !== "");
+const nulFields = (out) => out.split("\0").filter((l) => l !== "");
+/** `RepoGit` backed by the `git` executable in `cwd`. */
+export const gitReader = (cwd, debug) => {
+    const ok = (args) => gitOk(cwd, args, debug);
+    const resolve = async (ref) => {
+        const result = await run(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], debug);
+        return result.code === 0 ? result.stdout.trim() : undefined;
+    };
+    const tagRefs = async (extra) => {
+        const refs = lines(await ok([
+            "for-each-ref",
+            ...extra,
+            "--format=%(refname:strip=2)%00%(objecttype)%00%(objectname)%00%(*objecttype)%00%(*objectname)",
+            "refs/tags",
+        ])).map(async (line) => {
+            const [name = "", type = "", sha = "", peeledType = "", peeled = ""] = line.split("\0");
+            if (peeledType === "commit") {
+                return { name, sha: peeled };
+            }
+            if (type === "commit") {
+                return { name, sha };
+            }
+            // Older git peels one level only; tags of tags need a full peel.
+            const commit = await resolve(sha);
+            return commit === undefined ? undefined : { name, sha: commit };
+        });
+        return (await Promise.all(refs))
+            .filter((t) => t !== undefined)
+            .sort(byName);
+    };
+    const firstParents = new Map();
+    const firstParentSet = (ref) => {
+        let set = firstParents.get(ref);
+        if (set === undefined) {
+            set = ok(["rev-list", "--first-parent", ref]).then((out) => new Set(lines(out)));
+            firstParents.set(ref, set);
+        }
+        return set;
+    };
+    const range = (from, to) => from === null ? [to] : [to, `^${from}`];
+    return {
+        tags: () => tagRefs([]),
+        tagsMerged: (ref) => tagRefs([`--merged=${ref}`]),
+        isAncestor: async (a, b) => {
+            const result = await run(cwd, ["merge-base", "--is-ancestor", a, b], debug);
+            if (result.code > 1) {
+                throw new Error(`git merge-base failed: ${result.stderr.trim()}`);
+            }
+            return result.code === 0;
+        },
+        isFirstParentAncestor: async (a, b) => {
+            const sha = await resolve(a);
+            return sha !== undefined && (await firstParentSet(b)).has(sha);
+        },
+        log: async (from, to) => {
+            const out = await ok([
+                "log",
+                "-z",
+                "--no-show-signature",
+                "--no-color",
+                "--no-merges",
+                "--no-renames",
+                "--name-only",
+                "--format=%x1e%H%x00%P%x00%cI%x00%B%x00",
+                ...range(from, to),
+                "--",
+            ]);
+            return out
+                .split("\x1e")
+                .slice(1)
+                .map((record) => {
+                const [sha = "", parents = "", date = "", message = "", ...rest] = record.split("\0");
+                // Files follow the header as "\0\n" plus NUL-terminated paths.
+                const files = nulFields(rest.join("\0").replace(/^\0\n?/, ""));
+                return {
+                    sha,
+                    parents: parents.split(" ").filter((p) => p !== ""),
+                    message: message.trimEnd(),
+                    files: files.sort(),
+                    date,
+                };
+            });
+        },
+        countFirstParent: async (from, to) => Number((await ok([
+            "rev-list",
+            "--count",
+            "--first-parent",
+            ...range(from, to),
+        ])).trim()),
+        diffFiles: async (from, to) => nulFields(await ok([
+            "diff",
+            "-z",
+            "--no-color",
+            "--name-only",
+            "--no-renames",
+            from,
+            to,
+            "--",
+        ])).sort(),
+        resolve,
+        mergeBase: async (a, b) => {
+            const result = await run(cwd, ["merge-base", a, b], debug);
+            return result.code === 0 ? result.stdout.trim() : undefined;
+        },
+        isShallow: async () => (await ok(["rev-parse", "--is-shallow-repository"])).trim() === "true",
+        branch: async () => {
+            const result = await run(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], debug);
+            return result.code === 0 ? result.stdout.trim() : undefined;
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { version } from "./version.js";
+export { main } from "./main.js";
+export type { Deps, Writer } from "./session.js";
+export type { Forge, WorkflowRunQuery } from "./forge/forge.js";
+export type { RepoGit } from "./git/reader.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { version } from "./version.js";
+export { main } from "./main.js";

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+import type { Deps } from "./session.js";
+/** Runs the cli; returns the exit code (0 ok, 1 error, 2 usage). */
+export declare const main: (argv: readonly string[], deps: Deps) => Promise<number>;

package/dist/main.js

@@ -0,0 +1,66 @@
+import { CONFIG_FILE, TallyError } from "@tallyrelease/core";
+import { Command, CommanderError } from "commander";
+import { inspect } from "node:util";
+import { affected } from "./commands/affected.js";
+import { check } from "./commands/check.js";
+import { graph } from "./commands/graph.js";
+import { createSession } from "./session.js";
+import { version } from "./version.js";
+/** Runs the cli; returns the exit code (0 ok, 1 error, 2 usage). */
+export const main = async (argv, deps) => {
+    const program = new Command("tallyrelease")
+        .description("Affected build units for monorepos and single repos")
+        .version(version)
+        .option("--cwd <dir>", "repository root")
+        .option("--config <file>", "config file", CONFIG_FILE)
+        .option("--token <token>", "forge token (default: GITHUB_TOKEN)")
+        .option("--verbose", "print debug output")
+        .exitOverride()
+        .configureOutput({
+        writeOut: (s) => deps.stdout.write(s),
+        writeErr: (s) => deps.stderr.write(s),
+    });
+    const session = () => createSession(deps, program.opts());
+    program
+        .command("check")
+        .description("validate config, plugins, units and graph")
+        .action(async () => {
+        await check(session());
+    });
+    program
+        .command("graph")
+        .description("print units and edges")
+        .option("--json", "print JSON")
+        .action(async (flags) => {
+        await graph(session(), flags);
+    });
+    program
+        .command("affected")
+        .description("compute the build set")
+        .option("--base <ref>", "diff against this ref")
+        .option("--json", "print the affected document")
+        .option("--out <file>", "write the affected document to a file")
+        .option("--github-output", "append outputs to $GITHUB_OUTPUT")
+        .action(async (flags) => {
+        await affected(session(), flags);
+    });
+    try {
+        await program.parseAsync(argv, { from: "user" });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CommanderError) {
+            return error.exitCode === 0 ? 0 : 2;
+        }
+        if (error instanceof TallyError) {
+            deps.stderr.write(`${error.code}: ${error.message}\n`);
+        }
+        else {
+            deps.stderr.write(`E_INTERNAL: ${error instanceof Error ? error.message : String(error)}\n`);
+            if (program.opts().verbose) {
+                deps.stderr.write(`${inspect(error)}\n`);
+            }
+        }
+        return 1;
+    }
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@tallyrelease/core";
+export declare const builtinPlugins: Record<string, Plugin>;

package/dist/plugins/index.js

@@ -0,0 +1,6 @@
+import { nodePlugin } from "./node/index.js";
+import { phpPlugin } from "./php/index.js";
+export const builtinPlugins = {
+    node: nodePlugin,
+    php: phpPlugin,
+};

package/dist/plugins/node/index.d.ts

@@ -0,0 +1 @@
+export declare const nodePlugin: import("@tallyrelease/core").Plugin<unknown>;

package/dist/plugins/node/index.js

@@ -0,0 +1,100 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+import { parse as parseYaml } from "yaml";
+const PINNED_FIELDS = ["dependencies", "optionalDependencies"];
+const UNPINNED_FIELDS = ["peerDependencies", "devDependencies"];
+const EXACT = /^(workspace:)?(\*|=?v?\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?)$/;
+const manifestPath = (root) => root === "." ? "package.json" : `${root}/package.json`;
+const readManifest = (ctx, root) => {
+    const raw = ctx.fs.read(manifestPath(root));
+    return raw === undefined ? undefined : JSON.parse(raw);
+};
+/** Workspace globs from `pnpm-workspace.yaml` or `package.json`, if any. */
+const workspacePatterns = (ctx) => {
+    const pnpm = ctx.fs.read("pnpm-workspace.yaml");
+    if (pnpm !== undefined) {
+        const doc = parseYaml(pnpm);
+        return doc?.packages ?? [];
+    }
+    const { workspaces } = readManifest(ctx, ".") ?? {};
+    if (workspaces === undefined) {
+        return undefined;
+    }
+    return Array.isArray(workspaces) ? workspaces : (workspaces.packages ?? []);
+};
+const packageRoots = (ctx, patterns) => {
+    const manifests = (list) => ctx.fs.glob(list.map((p) => `${p.replace(/\/+$/, "")}/package.json`));
+    const excluded = new Set(manifests(patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1))));
+    return manifests(patterns.filter((p) => !p.startsWith("!")))
+        .filter((p) => !excluded.has(p))
+        .map((p) => p.slice(0, -"/package.json".length));
+};
+export const nodePlugin = definePlugin({
+    apiVersion: 1,
+    name: "node",
+    discover: (ctx) => {
+        const patterns = workspacePatterns(ctx);
+        const roots = patterns === undefined
+            ? ctx.fs.exists("package.json")
+                ? ["."]
+                : []
+            : packageRoots(ctx, patterns);
+        return roots.map((root) => {
+            const packageName = readManifest(ctx, root)?.name;
+            return {
+                id: defaultUnitId(root, ctx.repo.name),
+                root,
+                version: "file",
+                meta: packageName === undefined ? {} : { packageName },
+            };
+        });
+    },
+    edges: (ctx, units) => {
+        const byName = new Map();
+        for (const unit of units) {
+            const name = unit.meta["node"]?.["packageName"];
+            if (unit.plugin === "node" && typeof name === "string") {
+                const prior = byName.get(name);
+                if (prior) {
+                    ctx.log.warn(`package "${name}" is declared by "${prior.root}" and "${unit.root}"; using "${unit.root}"`);
+                }
+                byName.set(name, unit);
+            }
+        }
+        const edges = [];
+        for (const to of byName.values()) {
+            const manifest = readManifest(ctx, to.root) ?? {};
+            const fields = [
+                ...PINNED_FIELDS.map((field) => [field, true]),
+                ...UNPINNED_FIELDS.map((field) => [field, false]),
+            ];
+            for (const [field, pinnable] of fields) {
+                const deps = (manifest[field] ?? {});
+                for (const [name, range] of Object.entries(deps)) {
+                    const from = byName.get(name);
+                    if (from && from.id !== to.id) {
+                        edges.push({
+                            from: from.id,
+                            to: to.id,
+                            reason: `${field}: ${name}`,
+                            pinned: pinnable && EXACT.test(range),
+                        });
+                    }
+                }
+            }
+        }
+        return edges;
+    },
+    inputs: (ctx) => ({
+        global: [
+            "yarn.lock",
+            "package-lock.json",
+            "pnpm-lock.yaml",
+            "pnpm-workspace.yaml",
+            ".yarnrc.yml",
+            ".yarn/patches/**",
+            ...(workspacePatterns(ctx) === undefined ? [] : ["package.json"]),
+            "tsconfig*.json",
+            "turbo.json",
+        ],
+    }),
+});

package/dist/plugins/php/index.d.ts

@@ -0,0 +1 @@
+export declare const phpPlugin: import("@tallyrelease/core").Plugin<unknown>;

package/dist/plugins/php/index.js

@@ -0,0 +1,70 @@
+import { defaultUnitId, definePlugin } from "@tallyrelease/core";
+const EXACT = /^(self\.version|=?v?\d+\.\d+\.\d+(\.\d+)?(-[0-9A-Za-z.-]+)?)$/;
+const composerPath = (root) => root === "." ? "composer.json" : `${root}/composer.json`;
+const readComposer = (ctx, root) => {
+    const raw = ctx.fs.read(composerPath(root));
+    return raw === undefined ? undefined : JSON.parse(raw);
+};
+/** Local `repositories[type=path]` url globs, repo-relative. */
+const pathRepoGlobs = (composer) => {
+    const repos = Object.values((composer.repositories ?? {}));
+    return repos
+        .filter((r) => r.type === "path" && typeof r.url === "string")
+        .map((r) => (r.url ?? "").replace(/^\.\//, "").replace(/\/+$/, ""))
+        .filter((url) => url !== "" && !url.startsWith("../"));
+};
+export const phpPlugin = definePlugin({
+    apiVersion: 1,
+    name: "php",
+    discover: (ctx) => {
+        const rootComposer = readComposer(ctx, ".");
+        if (!rootComposer) {
+            return [];
+        }
+        const roots = [
+            ".",
+            ...ctx.fs
+                .glob(pathRepoGlobs(rootComposer).map((u) => `${u}/composer.json`))
+                .map((p) => p.slice(0, -"/composer.json".length))
+                .filter((root) => root !== ""),
+        ];
+        return roots.map((root) => {
+            const packageName = readComposer(ctx, root)?.name;
+            return {
+                id: defaultUnitId(root, ctx.repo.name),
+                root,
+                version: "tag",
+                meta: packageName === undefined ? {} : { packageName },
+            };
+        });
+    },
+    edges: (ctx, units) => {
+        const byName = new Map();
+        for (const unit of units) {
+            const name = unit.meta["php"]?.["packageName"];
+            if (unit.plugin === "php" && typeof name === "string") {
+                byName.set(name, unit);
+            }
+        }
+        const edges = [];
+        for (const to of byName.values()) {
+            const composer = readComposer(ctx, to.root) ?? {};
+            for (const field of ["require", "require-dev"]) {
+                const deps = (composer[field] ?? {});
+                for (const [name, constraint] of Object.entries(deps)) {
+                    const from = byName.get(name);
+                    if (from && from.id !== to.id) {
+                        edges.push({
+                            from: from.id,
+                            to: to.id,
+                            reason: `${field}: ${name}`,
+                            pinned: field === "require" && EXACT.test(constraint),
+                        });
+                    }
+                }
+            }
+        }
+        return edges;
+    },
+    inputs: () => ({ global: ["composer.lock"] }),
+});

package/dist/session.d.ts

@@ -0,0 +1,41 @@
+import type { Env, GithubContext } from "./ci/github-env.js";
+import type { Forge } from "./forge/forge.js";
+import type { RepoGit } from "./git/reader.js";
+import type { ReadonlyFs, Warning, Workspace } from "@tallyrelease/core";
+export interface Writer {
+    write: (chunk: string) => unknown;
+}
+/** Injected environment of a cli run; `bin.ts` wires the real one. */
+export interface Deps {
+    env: Env;
+    cwd: string;
+    stdout: Writer;
+    stderr: Writer;
+    /** Defaults to the `git` executable at the repo root. */
+    git?: RepoGit;
+    /** Defaults to `node:fs` at the repo root. */
+    fs?: ReadonlyFs;
+    /** Defaults to GitHub when a token is available; used only with a token. */
+    forge?: Forge;
+}
+export interface GlobalOptions {
+    cwd?: string;
+    config: string;
+    token?: string;
+    verbose?: boolean;
+}
+/** Resolved dependencies shared by all commands. */
+export interface Session {
+    readonly cwd: string;
+    readonly root: string;
+    readonly env: Env;
+    readonly stdout: Writer;
+    readonly fs: ReadonlyFs;
+    readonly git: RepoGit;
+    readonly github: GithubContext | undefined;
+    /** Undefined without a token. */
+    readonly forge: Forge | undefined;
+    readonly workspace: () => Promise<Workspace>;
+    readonly warn: (warnings: readonly Warning[]) => void;
+}
+export declare const createSession: (deps: Deps, opts: GlobalOptions) => Session;

package/dist/session.js

@@ -0,0 +1,77 @@
+import { loadWorkspace, TallyError } from "@tallyrelease/core";
+import { basename, relative, resolve, sep } from "node:path";
+import { githubContext } from "./ci/github-env.js";
+import { loadConfig } from "./config/load.js";
+import { githubForge } from "./forge/github.js";
+import { nodeFs } from "./fs-ctx.js";
+import { git as runGit } from "./git/exec.js";
+import { gitReader } from "./git/reader.js";
+import { builtinPlugins } from "./plugins/index.js";
+export const createSession = (deps, opts) => {
+    const root = resolve(deps.cwd, opts.cwd ?? ".");
+    const debug = opts.verbose
+        ? (message) => deps.stderr.write(`debug: ${message}\n`)
+        : undefined;
+    const fs = deps.fs ?? nodeFs(root);
+    const github = githubContext(deps.env);
+    const token = opts.token ?? deps.env["GITHUB_TOKEN"];
+    const configPath = relative(root, resolve(root, opts.config))
+        .split(sep)
+        .join("/");
+    // Injected git or fs means there is no repository on disk to query.
+    const onDisk = deps.git === undefined && deps.fs === undefined;
+    const assertRepoRoot = async () => {
+        const result = await runGit(root, ["rev-parse", "--show-toplevel", "--show-prefix"], debug);
+        const [toplevel = "", prefix = ""] = result.stdout.split("\n");
+        if (result.code === 0 && prefix !== "") {
+            throw new TallyError("E_NOT_REPO_ROOT", `"${root}" is below the repository root "${toplevel}"; run from the root or pass --cwd`, { cwd: root, toplevel });
+        }
+    };
+    // GITHUB_REPOSITORY, else the origin url, else the directory name.
+    const repoName = async () => {
+        const fromEnv = deps.env["GITHUB_REPOSITORY"]?.split("/")[1];
+        if (fromEnv) {
+            return fromEnv;
+        }
+        if (onDisk) {
+            const origin = await runGit(root, ["remote", "get-url", "origin"], debug);
+            const name = origin.code === 0
+                ? /([^/:]+?)(?:\.git)?\/*$/.exec(origin.stdout.trim())?.[1]
+                : undefined;
+            if (name) {
+                return name;
+            }
+        }
+        return basename(root);
+    };
+    return {
+        cwd: deps.cwd,
+        root,
+        env: deps.env,
+        stdout: deps.stdout,
+        fs,
+        git: deps.git ?? gitReader(root, debug),
+        github,
+        forge: token
+            ? (deps.forge ?? githubForge({ token, baseUrl: github?.apiUrl }))
+            : undefined,
+        workspace: async () => {
+            if (onDisk) {
+                await assertRepoRoot();
+            }
+            return await loadWorkspace({
+                config: loadConfig(fs, configPath),
+                configFile: configPath,
+                plugins: Object.values(builtinPlugins),
+                fs,
+                repo: { name: await repoName() },
+                ...(debug && { debug }),
+            });
+        },
+        warn: (warnings) => {
+            for (const w of warnings) {
+                deps.stderr.write(`${w.code}: ${w.plugin ? `${w.plugin}: ` : ""}${w.message}\n`);
+            }
+        },
+    };
+};

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.0.0";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = "0.0.0";