Use detect-monorepo for workspace root and rush detection (#175)

Use `detect-monorepo` to auto-detect the workspace root, replacing the
hardcoded `workspaceRoot: "../.."` default.

When `workspaceRoot` is not set explicitly (and `targetPackagePath` is
not used), `resolveWorkspacePaths` now walks upward from the target
package directory looking for `pnpm-workspace.yaml`, a `package.json`
with a `workspaces` field, or `rush.json`. If detection fails and no
`workspaceRoot` is configured, a clear error asks the user to set it
explicitly.

The `workspaceRoot` config option remains supported as an override for
cases where auto-detection fails (e.g. unusually deep nesting).

The existing `isRushWorkspace` helper is kept as a strict `rush.json`
check at the passed-in directory. It is intentionally not replaced with
`detectMonorepo`, because `detectMonorepo` walks upward and its rootDir
can diverge from `workspaceRootDir`, which would break callers that
compute lockfile importer ids or other paths relative to the same
directory.

Docs and CLI help text updated to reflect the new auto-detect behavior.

Scope: packages (isolate-package)
Visibility: user-facing

Author: 0x80

docs/api.md

@@ -36,7 +36,7 @@ or you can pass a configuration object directly:
 
 ```ts
 const packageNames = await getInternalPackageNames({
-  workspaceRoot: "../..",
+  includeDevDependencies: true,
 });
 ```
 
@@ -60,6 +60,6 @@ A helper for type-checked configuration files. Use it in `isolate.config.ts` or
 import { defineConfig } from "isolate-package";
 
 export default defineConfig({
-  workspaceRoot: "../..",
+  includeDevDependencies: true,
 });
 ```

docs/configuration.md

@@ -22,7 +22,7 @@ the `defineConfig` helper for type checking:
 import { defineConfig } from "isolate-package";
 
 export default defineConfig({
-  workspaceRoot: "../..",
+  includeDevDependencies: true,
 });
 ```
 
@@ -156,29 +156,17 @@ from the root of the workspace.
 
 ### workspaceRoot
 
-Type: `string`, default: `"../.."`
-
-The relative path to the root of the workspace / monorepo. In a typical setup
-you will have a `packages` directory and possibly also an `apps` and a
-`services` directory, all of which contain packages. So any package you would
-want to isolate is located 2 levels up from the root.
+Type: `string | undefined`, default: `undefined`
 
-For example
+The relative path from the target package directory to the root of the
+workspace / monorepo. When omitted, the workspace root is auto-detected by
+walking upward from the target package directory and looking for a
+`pnpm-workspace.yaml`, a `package.json` with a `workspaces` field, or a
+`rush.json`.
 
-```
-packages
-├─ backend
-│  └─ package.json
-└─ ui
-   └─ package.json
-apps
-├─ admin
-│  └─ package.json
-└─ web
-   └─ package.json
-services
-└─ api
-   └─ package.json
-```
+You only need to set this explicitly when auto-detection fails, for example
+when the target package is nested more than a few levels deep inside the
+workspace.
 
-When you use the `targetPackagePath` option, this setting will be ignored.
+When you use the `targetPackagePath` option, this setting is ignored and the
+workspace root is assumed to be the current working directory.

package.json

@@ -55,6 +55,7 @@
     "@pnpm/logger": "^1001.0.1",
     "@pnpm/types": "^1001.3.0",
     "consola": "^3.4.2",
+    "detect-monorepo": "^1.0.0",
     "fs-extra": "^11.3.4",
     "get-or-throw": "^3.0.1",
     "get-tsconfig": "^4.13.7",

pnpm-lock.yaml

@@ -24,15 +24,15 @@ const cli = meow(
       -t, --target-package-path <path>       Path to the target package
       -c, --tsconfig-path <path>             Path to tsconfig.json (default: ./tsconfig.json)
       -w, --workspace-packages <glob>        Workspace package globs (repeatable)
-      -r, --workspace-root <path>            Path to the workspace root (default: ../..)
+      -r, --workspace-root <path>            Path to the workspace root (auto-detected by default)
           --force-npm                        Force npm lockfile generation
       -p, --pick-from-scripts <name>         Scripts to include (repeatable)
           --omit-from-scripts <name>         Scripts to exclude (repeatable)
           --omit-package-manager             Omit the packageManager field from the manifest
 
     Examples
       $ isolate --log-level debug
-      $ isolate --force-npm --workspace-root ../..
+      $ isolate --force-npm
       $ isolate --pick-from-scripts build --pick-from-scripts start
   `,
   {

src/isolate-bin.ts

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { detectMonorepo } from "detect-monorepo";
 import fs from "fs-extra";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -14,7 +15,13 @@ export type IsolateConfigResolved = {
   targetPackagePath?: string;
   tsconfigPath: string;
   workspacePackages?: string[];
-  workspaceRoot: string;
+  /**
+   * Path to the workspace root, relative to the target package directory.
+   * When omitted, the workspace root is auto-detected by walking upward from
+   * the target package directory looking for a pnpm-workspace.yaml, a
+   * package.json with a `workspaces` field, or a rush.json.
+   */
+  workspaceRoot?: string;
   forceNpm: boolean;
   pickFromScripts?: string[];
   omitFromScripts?: string[];
@@ -31,7 +38,7 @@ const configDefaults: IsolateConfigResolved = {
   targetPackagePath: undefined,
   tsconfigPath: "./tsconfig.json",
   workspacePackages: undefined,
-  workspaceRoot: "../..",
+  workspaceRoot: undefined,
   forceNpm: false,
   pickFromScripts: undefined,
   omitFromScripts: undefined,
@@ -170,17 +177,35 @@ function validateConfig(config: IsolateConfig) {
  * Resolve the target package directory and workspace root directory from the
  * configuration. When targetPackagePath is set, the config is assumed to live
  * at the workspace root. Otherwise it lives in the target package directory.
+ *
+ * When `workspaceRoot` is not explicitly set, auto-detect the monorepo root by
+ * walking upward from the target package directory.
  */
 export function resolveWorkspacePaths(config: IsolateConfigResolved) {
   const targetPackageDir = config.targetPackagePath
     ? path.join(process.cwd(), config.targetPackagePath)
     : process.cwd();
 
-  const workspaceRootDir = config.targetPackagePath
-    ? process.cwd()
-    : path.join(targetPackageDir, config.workspaceRoot);
+  if (config.targetPackagePath) {
+    return { targetPackageDir, workspaceRootDir: process.cwd() };
+  }
+
+  if (config.workspaceRoot !== undefined) {
+    return {
+      targetPackageDir,
+      workspaceRootDir: path.join(targetPackageDir, config.workspaceRoot),
+    };
+  }
+
+  const detected = detectMonorepo(targetPackageDir);
+
+  if (!detected) {
+    throw new Error(
+      `Failed to auto-detect monorepo workspace root from ${targetPackageDir}. Set the 'workspaceRoot' config option explicitly.`,
+    );
+  }
 
-  return { targetPackageDir, workspaceRootDir };
+  return { targetPackageDir, workspaceRootDir: detected.rootDir };
 }
 
 export function resolveConfig(

src/lib/config.ts

@@ -4,6 +4,12 @@ import path from "node:path";
 /**
  * Detect if this is a Rush monorepo. They use a very different structure so
  * there are multiple places where we need to make exceptions based on this.
+ *
+ * This intentionally only checks the passed-in directory. Using the upward
+ * walk of `detectMonorepo` here would break callers that pass a subdirectory
+ * of the actual Rush root, because downstream code builds paths (like
+ * `common/config/rush`) and lockfile importer ids relative to the same
+ * directory it gets.
  */
 export function isRushWorkspace(workspaceRootDir: string) {
   return fs.existsSync(path.join(workspaceRootDir, "rush.json"));