@fuman/build 0.0.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2024 alina sireneva
+
+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,108 @@
+## @fuman/build
+
+this package contains utilities for building packages and managing monorepos.
+
+existing similar tools try to do too much and accomodate for every possible use case,
+which makes them quite hard to use and don't provide enough consistency.
+unlike them, this package is *very* opinionated and might not be for you.
+
+this package works on some assumptions, allowing to abstract some of the complexity away:
+ - for workspaces, it assumes that the workspace is managed with pnpm
+   - packages within the workspace are linked using [`workspace:` protocol](https://pnpm.io/workspaces#workspace-protocol-workspace),
+     and versions are replaced with the actual version at build time
+ - packages are built using vite (i.e. rollup). i might support some other bundler down the line, though
+   - tsc is explicitly **not** supported, because using `tsc` to build is such a pain that it's just not worth it.
+ - all packages must be `type: module`, because commonjs sucks (you can still build into commonjs, tho)
+ - `.exports` and `.bin` fields in package.json are build entrypoints, e.g.:
+   ```json
+   {
+       "exports": {
+           ".": "./src/index.ts"
+       },
+       "bin": {
+           "fuman-build": "./src/cli.ts"
+       }
+   }
+ - `.main`, `.module`, `.types`, `.browser` are explicitly **not** supported. for browser-specific code, you should make a secondary entrypoint/package instead of relying on bundle-time magic
+ - package versioning is continous and semver-compliant (except "fixed version" releases, which all share the same version)
+ - this package currently focuses on non-frontend libraries
+
+it *might* work with other setups, but that is not supported.
+
+### why exactly?
+
+because node sucks. `package.json` is an absolute mess – it's not standardized properly, and it's a pain to work with.
+when it was invented, typescript wasn't even a thing, and as such it's a pain to set it up correctly for libraries.
+and npm is also a pain due to similar reasons. everything is so fragile and inconsistent that it's very easy to make mistakes.
+
+deno and jsr fix some of the issues, but i just generally don't like deno because it feels very limiting and vendor-locking,
+and there isn't any tool to write cross-runtime code under deno anyway.
+
+additionally there's quite some pain writing release ci/cd flows for libraries.
+especially for monorepos, especially when you want to cross-publish to npm and jsr.
+
+### package.json pre-processing features
+
+...provided by `processPackageJson` function
+ - copying common fields from root package.json
+ - replacing `workspace:` dependencies with the actual version from the workspace
+ - removing `scripts` (except ones listed in `keepScripts`)
+ - removing `devDependencies`, `typedoc`/`prettier`/etc
+ - collecting entrypoints from `exports` and `bin`
+ - running hooks declared in `build.config.js` files
+
+this allows to:
+ - simplify the inner package.jsons and keep them in sync with the root package.json
+ - simplify the release flow by not having to manually update dependency versions in each package
+   - (i know that pnpm/yarn basically fix this with `workspace:` protocol, but i don't like the idea of using something other than npm cli to publish to npm)
+ - ensures you don't accidentally publish unwanted `prepare`/`install`/etc. scripts to npm (and also reduces install size by a bit)
+ - reduces install size a bit
+ - improve dx by *a lot*
+   - you no longer need to build the packages before you can import them, nor do you need to repeat yourself by manually providing `.types` field for development
+   - you no longer need to sync vite build entrypoints with `package.json` across all packages (and accidentally publish them broken)
+ - since we generate a new package.json, you can do pretty much any modifications to the production package.json
+   (despite the above, there might still be cases that we don't cover and you want a bit more control.
+   feel free to open an issue if you feel like this should be in the package tho!)
+
+## usage with vite
+
+just put this in your `vite.config.js`:
+```ts
+import { fumanBuild } from '@fuman/build/vite'
+
+export default {
+    plugins: [
+        fumanBuild({
+            root: __dirname,
+            // if you're using `vite-plugin-dts`, make sure to add this option,
+            // otherwise additional entrypoints will not have proper types
+            // (and DO NOT add this option to the dts plugin itself)
+            insertTypesEntry: true,
+        }),
+    ],
+}
+```
+
+## usage with jsr
+
+fuman-build also supports jsr by being able to convert a pnpm workspace into a deno workspace,
+which can then be published via simple `deno publish` command.
+
+to generate a deno workspace, run `fuman-build jsr gen-deno-workspace`.
+
+## cli
+
+fuman-build has a pretty cool cli, check it out via `fuman-build --help`
+
+## ci/cd
+
+fuman-build also makes it *very* easy to use in CI/CD pipelines.
+a very simple release flow powered by fuman build and github actions
+can be found [here](https://github.com/teidesu/fuman/blob/main/.github/workflows/release.yaml).
+
+the `release` command basically combines a bunch of other commands
+(namely, `bump-version`, `gen-changelog`, `publish` and `jsr` subcommands)
+into one and adds some additional release-specific features (like git tagging and github release generation), and is the recommended way to use fuman-build in CI/CD pipelines.
+
+though it is definitely possible to use the other commands directly, in case
+you need to do something that is not supported out of the box.

package/ci/github-actions.d.ts

@@ -0,0 +1,3 @@
+export declare function isRunningInGithubActions(): boolean;
+export declare function getGithubActionsInput(name: string): string | undefined;
+export declare function writeGithubActionsOutput(name: string, value: string): void;

package/ci/github-actions.js

@@ -0,0 +1,28 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { EOL } from "node:os";
+import process from "node:process";
+function isRunningInGithubActions() {
+  return Boolean(process.env.GITHUB_ACTIONS);
+}
+function getGithubActionsInput(name) {
+  const input = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`];
+  if (input === void 0) return void 0;
+  return input.trim();
+}
+function writeGithubActionsOutput(name, value) {
+  if (process.env.GITHUB_OUTPUT === void 0) {
+    throw new Error("GITHUB_OUTPUT is not set");
+  }
+  if (!value.includes(EOL)) {
+    appendFileSync(process.env.GITHUB_OUTPUT, `${name}=${value}${EOL}`, "utf8");
+    return;
+  }
+  const delim = `---${randomUUID()}---${EOL}`;
+  appendFileSync(process.env.GITHUB_OUTPUT, `${name}<<${delim}${value}${delim}`, "utf8");
+}
+export {
+  getGithubActionsInput,
+  isRunningInGithubActions,
+  writeGithubActionsOutput
+};

package/ci/index.d.ts

@@ -0,0 +1 @@
+export * from './github-actions.js';

package/cli/commands/_utils.d.ts

@@ -0,0 +1,8 @@
+import { RootConfigObject } from '../../config.js';
+import * as bc from '@drizzle-team/brocli';
+export { bc };
+export declare function loadConfig(params: {
+    workspaceRoot: string;
+    configPath?: string;
+    require?: boolean;
+}): Promise<RootConfigObject | null>;

package/cli/commands/_utils.js

@@ -0,0 +1,18 @@
+import * as bc from "@drizzle-team/brocli";
+import { loadBuildConfig } from "../../misc/_config.js";
+async function loadConfig(params) {
+  const {
+    workspaceRoot,
+    configPath = "build.config.js",
+    require: require2 = true
+  } = params;
+  const config = await loadBuildConfig(workspaceRoot, configPath);
+  if (!config && require2) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+  return config ?? null;
+}
+export {
+  bc,
+  loadConfig
+};

package/cli/commands/build.d.ts

@@ -0,0 +1,20 @@
+import { WorkspacePackage } from '../../package-json/collect-package-jsons.js';
+import { bc } from './_utils.js';
+export declare function buildPackage(params: {
+    workspaceRoot: string;
+    workspace?: WorkspacePackage[];
+    packageName: string;
+    configPath?: string;
+    fixedVersion?: string;
+}): Promise<void>;
+export declare const buildPackageCli: bc.Command<{
+    config: string | undefined;
+    root: string | undefined;
+    packageName: string;
+    fixedVersion: string | undefined;
+}, {
+    config: string | undefined;
+    root: string | undefined;
+    packageName: string;
+    fixedVersion: string | undefined;
+}>;

package/cli/commands/build.js

@@ -0,0 +1,45 @@
+import { join } from "node:path";
+import process from "node:process";
+import { exec } from "../../misc/exec.js";
+import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import { findPackageByName } from "../../package-json/utils.js";
+import { loadConfig } from "./_utils.js";
+import * as bc from "@drizzle-team/brocli";
+async function buildPackage(params) {
+  const config = await loadConfig(params);
+  const workspacePackages = params.workspace ?? await collectPackageJsons(params.workspaceRoot, true);
+  const viteConfig = config?.viteConfig ?? "vite.config.js";
+  const packageRoot = findPackageByName(workspacePackages, params.packageName).path;
+  await exec(["npx", "vite", "build", "--config", join(params.workspaceRoot, viteConfig)], {
+    env: {
+      ...process.env,
+      __FUMAN_INTERNAL_PACKAGES_LIST: JSON.stringify(workspacePackages),
+      __FUMAN_INTERNAL_FIXED_VERSION: params.fixedVersion
+    },
+    cwd: packageRoot,
+    stdio: "inherit",
+    throwOnError: true
+  });
+}
+const buildPackageCli = bc.command({
+  name: "build",
+  desc: "build a package",
+  options: {
+    config: bc.string("config").desc("path to the build.config.js file"),
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    packageName: bc.positional("package-name").desc("name of the package to build").required(),
+    fixedVersion: bc.string("fixed-version").desc("version to publish the package to (overrides the version in every package.json, useful for pre-releases)")
+  },
+  handler: async (args) => {
+    await buildPackage({
+      workspaceRoot: args.root ?? process.cwd(),
+      packageName: args.packageName,
+      configPath: args.config,
+      fixedVersion: args.fixedVersion
+    });
+  }
+});
+export {
+  buildPackage,
+  buildPackageCli
+};

package/cli/commands/bump-version.d.ts

@@ -0,0 +1,18 @@
+import { BumpVersionResult } from '../../versioning/bump-version.js';
+import { bc } from './_utils.js';
+export declare function formatBumpVersionResult(result: BumpVersionResult, withReleaseType: boolean): string;
+export declare const bumpVersionCli: bc.Command<{
+    root: string | undefined;
+    config: string | undefined;
+    type: "auto" | "major" | "minor" | "patch";
+    since: string | undefined;
+    dryRun: boolean | undefined;
+    quiet: boolean | undefined;
+}, {
+    root: string | undefined;
+    config: string | undefined;
+    type: "auto" | "major" | "minor" | "patch";
+    since: string | undefined;
+    dryRun: boolean | undefined;
+    quiet: boolean | undefined;
+}>;

package/cli/commands/bump-version.js

@@ -0,0 +1,72 @@
+import process from "node:process";
+import { isRunningInGithubActions, writeGithubActionsOutput } from "../../ci/github-actions.js";
+import { getLatestTag } from "../../git/utils.js";
+import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import { bumpVersion } from "../../versioning/bump-version.js";
+import { loadConfig } from "./_utils.js";
+import * as bc from "@drizzle-team/brocli";
+function formatBumpVersionResult(result, withReleaseType) {
+  const lines = [];
+  if (withReleaseType) {
+    lines.push(`detected release type: ${result.releaseType}`);
+    lines.push(`  has breaking changes: ${result.hasBreakingChanges}`);
+    lines.push(`  has new features: ${result.hasFeatures}`);
+    lines.push("");
+  }
+  lines.push(`next version: ${result.nextVersion}`);
+  lines.push("");
+  lines.push("list of changed packages:");
+  for (const { package: pkg, because } of result.changedPackages) {
+    lines.push(`  ${pkg.json.name}${because ? ` (because of ${because.join(", ")})` : ""}: ${pkg.json.version} → ${result.nextVersion}`);
+  }
+  return lines.join("\n");
+}
+const bumpVersionCli = bc.command({
+  name: "bump-version",
+  desc: "bump the version of changed packages",
+  options: {
+    root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
+    config: bc.string().desc("path to the build.config.js file"),
+    type: bc.string().desc("override type of release (major, minor, patch) (default: auto-detect)").enum("major", "minor", "patch", "auto").default("auto"),
+    since: bc.string().desc("starting point for the changelog (default: latest tag)"),
+    dryRun: bc.boolean("dry-run").desc("whether to only print the detected changes without actually modifying anything"),
+    quiet: bc.boolean().desc("whether to only print the new version number").alias("q")
+  },
+  handler: async (args) => {
+    const root = args.root ?? process.cwd();
+    const releaseType = args.type === "auto" ? void 0 : args.type;
+    const workspace = await collectPackageJsons(root);
+    const config = await loadConfig({
+      workspaceRoot: root,
+      configPath: args.config,
+      require: false
+    });
+    const since = args.since ?? await getLatestTag(root);
+    if (since == null) {
+      throw new Error("no previous tag found, cannot determine changeset");
+    }
+    const result = await bumpVersion({
+      workspace,
+      type: releaseType,
+      cwd: root,
+      since,
+      params: config?.versioning,
+      dryRun: args.dryRun
+    });
+    if (args.quiet) {
+      console.log(result.nextVersion);
+    } else {
+      console.log(formatBumpVersionResult(result, releaseType == null));
+    }
+    if (isRunningInGithubActions()) {
+      writeGithubActionsOutput("version", result.nextVersion);
+      writeGithubActionsOutput("hasBreakingChanges", String(result.hasBreakingChanges));
+      writeGithubActionsOutput("hasFeatures", String(result.hasFeatures));
+      writeGithubActionsOutput("changedPackages", result.changedPackages.map((it) => it.package.json.name).join(","));
+    }
+  }
+});
+export {
+  bumpVersionCli,
+  formatBumpVersionResult
+};

package/cli/commands/cr.d.ts

@@ -0,0 +1,17 @@
+import { WorkspacePackage } from '../../package-json/collect-package-jsons.js';
+import { bc } from './_utils.js';
+export declare function runContinuousRelease(params: {
+    workspaceRoot?: string;
+    workspace?: WorkspacePackage[];
+    distDir?: string;
+    extraArgs?: string[];
+}): Promise<void>;
+export declare const runContinuousReleaseCli: bc.Command<{
+    root: string | undefined;
+    distDir: string | undefined;
+    extraArgs: string | undefined;
+}, {
+    extraArgs: string[] | undefined;
+    root: string | undefined;
+    distDir: string | undefined;
+}>;

package/cli/commands/cr.js

@@ -0,0 +1,76 @@
+import { join } from "node:path";
+import process from "node:process";
+import { asNonNull } from "@fuman/utils";
+import { isRunningInGithubActions } from "../../ci/github-actions.js";
+import { exec } from "../../misc/exec.js";
+import { collectPackageJsons, filterPackageJsonsForPublish } from "../../package-json/collect-package-jsons.js";
+import * as bc from "@drizzle-team/brocli";
+import { buildPackage } from "./build.js";
+async function runContinuousRelease(params) {
+  const {
+    workspaceRoot = process.cwd(),
+    workspace = await collectPackageJsons(workspaceRoot, true),
+    distDir = "dist",
+    extraArgs = []
+  } = params;
+  const workspaceWithoutRoot = workspace.filter((pkg) => !pkg.root);
+  const ordered = filterPackageJsonsForPublish(workspaceWithoutRoot, "npm");
+  if (!isRunningInGithubActions()) {
+    throw new Error("cr command is only supported in github actions");
+  }
+  const distPaths = [];
+  for (const pkg of ordered) {
+    if (pkg.json.scripts?.build !== void 0) {
+      await exec([
+        "npm",
+        "run",
+        "build"
+      ], {
+        cwd: join(pkg.path),
+        stdio: "inherit",
+        throwOnError: true
+      });
+    } else {
+      await buildPackage({
+        workspaceRoot,
+        workspace,
+        packageName: asNonNull(pkg.json.name)
+      });
+    }
+    distPaths.push(join(pkg.path, distDir));
+  }
+  if (extraArgs.some((it) => it.startsWith("--pnpm"))) {
+    console.warn("`--pnpm` flag is not supported and may cause issues, please avoid using it");
+  }
+  await exec([
+    "npx",
+    "pkg-pr-new",
+    "publish",
+    ...extraArgs,
+    ...distPaths
+  ], {
+    cwd: workspaceRoot,
+    throwOnError: true,
+    stdio: "inherit"
+  });
+}
+const runContinuousReleaseCli = bc.command({
+  name: "cr",
+  desc: "publish the workspace to pkg.pr.new",
+  options: {
+    root: bc.string().desc("path to the root of the workspace (default: cwd)"),
+    distDir: bc.string("dist-dir").desc("directory to publish from, relative to package root (default: dist)"),
+    extraArgs: bc.string("extra-args").desc("extra arguments to pass to pkg-pr-new")
+  },
+  transform: (args) => {
+    return {
+      ...args,
+      extraArgs: args.extraArgs?.split(" ")
+    };
+  },
+  handler: runContinuousRelease
+});
+export {
+  runContinuousRelease,
+  runContinuousReleaseCli
+};

package/cli/commands/find-changed-packages.d.ts

@@ -0,0 +1,12 @@
+import { bc } from './_utils.js';
+export declare const findChangedPackagesCli: bc.Command<{
+    root: string | undefined;
+    config: string | undefined;
+    since: string | undefined;
+    until: string | undefined;
+}, {
+    root: string | undefined;
+    config: string | undefined;
+    since: string | undefined;
+    until: string | undefined;
+}>;

package/cli/commands/find-changed-packages.js

@@ -0,0 +1,44 @@
+import process from "node:process";
+import { isRunningInGithubActions, writeGithubActionsOutput } from "../../ci/github-actions.js";
+import { getLatestTag } from "../../git/utils.js";
+import { findProjectChangedPackages } from "../../versioning/collect-files.js";
+import { loadConfig } from "./_utils.js";
+import * as bc from "@drizzle-team/brocli";
+const findChangedPackagesCli = bc.command({
+  name: "find-changed-packages",
+  desc: "find changed packages between two commits, and output a comma-separated list of package names",
+  options: {
+    root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
+    config: bc.string("config").desc("path to the build.config.js file"),
+    since: bc.string().desc("starting point for the changelog (default: latest tag)"),
+    until: bc.string().desc("ending point for the changelog (default: HEAD)")
+  },
+  handler: async (args) => {
+    const root = args.root ?? process.cwd();
+    const config = await loadConfig({
+      workspaceRoot: root,
+      configPath: args.config,
+      require: false
+    });
+    const since = args.since ?? await getLatestTag(root);
+    if (since == null) {
+      throw new Error("no previous tag found, cannot determine changeset");
+    }
+    const list = await findProjectChangedPackages({
+      params: config?.versioning,
+      root,
+      since,
+      until: args.until
+    });
+    const result = list.map((pkg) => pkg.json.name).join(",");
+    if (isRunningInGithubActions()) {
+      writeGithubActionsOutput("packages", result);
+      console.log("Written packages to `packages` output");
+    } else {
+      console.log(result);
+    }
+  }
+});
+export {
+  findChangedPackagesCli
+};

package/cli/commands/gen-changelog.d.ts

@@ -0,0 +1,12 @@
+import { bc } from './_utils.js';
+export declare const generateChangelogCli: bc.Command<{
+    only: string | undefined;
+    root: string | undefined;
+    config: string | undefined;
+    since: string | undefined;
+}, {
+    only: string | undefined;
+    root: string | undefined;
+    config: string | undefined;
+    since: string | undefined;
+}>;

package/cli/commands/gen-changelog.js

@@ -0,0 +1,49 @@
+import process from "node:process";
+import { isRunningInGithubActions, writeGithubActionsOutput } from "../../ci/github-actions.js";
+import { getLatestTag } from "../../git/utils.js";
+import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import { generateChangelog } from "../../versioning/generate-changelog.js";
+import { loadConfig } from "./_utils.js";
+import * as bc from "@drizzle-team/brocli";
+const generateChangelogCli = bc.command({
+  name: "gen-changelog",
+  desc: "generate a changelog for the workspace",
+  options: {
+    only: bc.string().desc("comma-separated list of packages to include"),
+    root: bc.string().desc("path to the root of the workspace (default: process.cwd())"),
+    config: bc.string("config").desc("path to the build.config.js file"),
+    since: bc.string().desc("starting point for the changelog (default: latest tag)")
+  },
+  handler: async (args) => {
+    const root = args.root ?? process.cwd();
+    const config = await loadConfig({
+      workspaceRoot: root,
+      configPath: args.config,
+      require: false
+    });
+    let workspacePackages = await collectPackageJsons(root, false);
+    if (args.only !== void 0) {
+      const only = new Set(args.only.split(",").map((s) => s.trim()));
+      workspacePackages = workspacePackages.filter((pkg) => only.has(pkg.json.name));
+    }
+    const since = args.since ?? await getLatestTag(root);
+    if (since == null) {
+      throw new Error("no previous tag found, cannot determine changeset");
+    }
+    const changelog = await generateChangelog({
+      workspace: workspacePackages,
+      cwd: root,
+      since,
+      params: config?.versioning
+    });
+    if (isRunningInGithubActions()) {
+      writeGithubActionsOutput("changelog", changelog);
+      console.log("Written changelog to `changelog` output");
+    } else {
+      console.log(changelog);
+    }
+  }
+});
+export {
+  generateChangelogCli
+};

package/cli/commands/gen-deps-graph.d.ts

@@ -0,0 +1,15 @@
+import { bc } from './_utils.js';
+export declare function generateDepsGraph(params: {
+    workspaceRoot: string | URL;
+    includeRoot?: boolean;
+    includeExternal?: boolean;
+}): Promise<string>;
+export declare const generateDepsGraphCli: bc.Command<{
+    includeRoot: boolean | undefined;
+    includeExternal: boolean | undefined;
+    root: string | undefined;
+}, {
+    includeRoot: boolean | undefined;
+    includeExternal: boolean | undefined;
+    root: string | undefined;
+}>;

package/cli/commands/gen-deps-graph.js

@@ -0,0 +1,78 @@
+import process from "node:process";
+import { collectPackageJsons } from "../../package-json/collect-package-jsons.js";
+import * as bc from "@drizzle-team/brocli";
+async function generateDepsGraph(params) {
+  const {
+    workspaceRoot,
+    includeRoot = false,
+    includeExternal = false
+  } = params;
+  const pjs = await collectPackageJsons(workspaceRoot, includeRoot);
+  const workspacePackages = /* @__PURE__ */ new Set();
+  let commonPrefix;
+  for (const { json: pj } of pjs) {
+    if (pj.name === void 0) continue;
+    workspacePackages.add(pj.name);
+    const [org, name] = pj.name.split("/");
+    if (!name) {
+      if (commonPrefix !== void 0) {
+        commonPrefix = void 0;
+      }
+      break;
+    }
+    if (commonPrefix === void 0) {
+      commonPrefix = org;
+    } else if (commonPrefix !== org) {
+      commonPrefix = void 0;
+      break;
+    }
+  }
+  const getName = (name) => {
+    if (commonPrefix !== void 0) {
+      const [org, pkg] = name.split("/");
+      if (org === commonPrefix) {
+        return pkg;
+      }
+    }
+    return name;
+  };
+  const lines = [];
+  for (const { json: pj } of pjs) {
+    if (pj.name === void 0) continue;
+    const name = getName(pj.name);
+    for (const dep of Object.keys(pj.dependencies || {})) {
+      if (!workspacePackages.has(dep) && !includeExternal) continue;
+      const depName = getName(dep);
+      lines.push(`"${name}" -> "${depName}"`);
+    }
+    for (const dep of Object.keys(pj.devDependencies || {})) {
+      if (!workspacePackages.has(dep) && !includeExternal) continue;
+      const depName = getName(dep);
+      lines.push(`"${name}" -> "${depName}" [style=dashed,color=grey]`);
+    }
+  }
+  return `digraph {
+${lines.join("\n")}
+}`;
+}
+const generateDepsGraphCli = bc.command({
+  name: "gen-deps-graph",
+  desc: "generate a graphviz dot file of the workspace dependencies",
+  options: {
+    includeRoot: bc.boolean("include-root").desc("whether to include the root package.json in the graph"),
+    includeExternal: bc.boolean("include-external").desc("whether to include external dependencies in the graph"),
+    root: bc.string().desc("path to the root of the workspace (default: cwd)")
+  },
+  handler: async (args) => {
+    const dot = await generateDepsGraph({
+      workspaceRoot: args.root ?? process.cwd(),
+      includeRoot: args.includeRoot,
+      includeExternal: args.includeExternal
+    });
+    console.log(dot);
+  }
+});
+export {
+  generateDepsGraph,
+  generateDepsGraphCli
+};

package/cli/commands/jsr.d.ts

@@ -0,0 +1,6 @@
+import { bc } from './_utils.js';
+export declare const jsrCli: bc.Command<{
+    [x: string]: bc.OutputType;
+} | undefined, {
+    [x: string]: bc.OutputType;
+} | undefined>;