@devdogsuga/devtools 0.1.49 → 0.1.51-next.526

package/dist/peers-DvUH5VxX.js

@@ -1,354 +0,0 @@
-import { r as findRepoRoot, t as RepoNotFoundError } from "./root-CjPWNkBu.js";
-import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
-/** The directory (relative to a Backstage root) holding the DevDogsUGA checkout. */
-const DEVDOGSUGA_LINK = "devdogsuga";
-var DevdogsugaMissingError = class extends Error {
-	constructor(path) {
-		super(`The DevDogsUGA checkout is missing at ${path}. Run \`pnpm devdogsuga\` (links the sibling clone, or \$DEVDOGSUGA_DIR) or \`pnpm install\` in the Backstage root first.`);
-		this.name = "DevdogsugaMissingError";
-	}
-};
-/** The kind of repo `dir` is the root of, by its `package.json` name; null if neither. */
-function repoKindOf(dir) {
-	try {
-		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-		if (pkg.name === "devdogs-monorepo") return "devdogsuga";
-		if (pkg.name === "backstage") return "backstage";
-	} catch {}
-	return null;
-}
-function isDir(path) {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
-	}
-}
-/**
-* The layout of the repo rooted at `root`. Pure: nothing is memoized, so tests
-* can build fixtures freely. An unrecognised package name is treated as
-* DevDogsUGA (the contract fixtures and every pre-Backstage caller).
-*/
-function layoutAt(root) {
-	const kind = repoKindOf(root) === "backstage" ? "backstage" : "devdogsuga";
-	const sibling = join(root, DEVDOGSUGA_LINK);
-	const hasDevdogsuga = kind === "devdogsuga" || isDir(sibling);
-	const devdogsugaRoot = kind === "devdogsuga" ? root : sibling;
-	const appsDirs = [join(root, "apps")];
-	if (kind === "backstage" && hasDevdogsuga) appsDirs.push(join(devdogsugaRoot, "apps"));
-	return {
-		kind,
-		root,
-		get devdogsugaRoot() {
-			if (!hasDevdogsuga) throw new DevdogsugaMissingError(sibling);
-			return devdogsugaRoot;
-		},
-		...kind === "backstage" ? { backstageRoot: root } : {},
-		hasDevdogsuga,
-		appsDirs: appsDirs.filter(isDir),
-		envMirrors: kind === "backstage" && hasDevdogsuga ? [devdogsugaRoot] : []
-	};
-}
-/** `layout.devdogsugaRoot`, or null instead of a throw when the checkout is missing. */
-function devdogsugaRootOrNull(layout) {
-	return layout.hasDevdogsuga ? layout.devdogsugaRoot : null;
-}
-let cached;
-let cachedFor;
-/** The layout of the repo the process is in (`findRepoRoot()`), memoized per root. */
-function resolveLayout() {
-	const root = findRepoRoot();
-	if (cached === void 0 || cachedFor !== root) {
-		cached = layoutAt(root);
-		cachedFor = root;
-	}
-	return cached;
-}
-/** Every directory under `appsDirs` (one app each), de-duplicated by name, sorted by name. */
-function listApps(layout = resolveLayout()) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const parent of layout.appsDirs) for (const entry of readdirSync(parent, { withFileTypes: true })) {
-		if (!entry.isDirectory()) continue;
-		if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-		if (!seen.has(entry.name)) seen.set(entry.name, {
-			name: entry.name,
-			dir: join(parent, entry.name)
-		});
-	}
-	return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-/** The directory of the app called `name`, or undefined when no repo has it. */
-function findApp(name, layout = resolveLayout()) {
-	return listApps(layout).find((app) => app.name === name)?.dir;
-}
-/**
-* Resolves a workspace-relative path such as `workers.json`'s
-* `apps/schedule-builder` to a directory: the repo you are in first, then
-* DevDogsUGA's. When neither has it the first candidate is returned, so
-* callers get an ordinary ENOENT naming the path rather than a second error.
-*/
-function resolveAppPath(relative, layout = resolveLayout()) {
-	const first = join(layout.root, relative);
-	if (existsSync(first)) return first;
-	if (layout.kind === "backstage" && layout.hasDevdogsuga) {
-		const second = join(layout.devdogsugaRoot, relative);
-		if (existsSync(second)) return second;
-	}
-	return first;
-}
-/**
-* The pnpm workspace root holding the app called `name`: where
-* `pnpm --filter <name>` has to run. DevDogsUGA's root for its apps seen from a
-* Backstage checkout, `layout.root` otherwise.
-*/
-function appWorkspaceRoot(name, layout = resolveLayout()) {
-	const dir = findApp(name, layout);
-	return dir === void 0 ? layout.root : dirname(dirname(dir));
-}
-//#endregion
-//#region ../cli-core/src/repo/resolve.ts
-/**
-* Resolves an `@devdogsuga/*` package FROM the target repo, not from
-* devtools' own (dlx-isolated) `node_modules`.
-*
-* Ported from the `devtools-dlx` prototype
-* (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
-* experiments 2 and 4 — read that file for the two gotchas this module
-* exists to avoid). The short version:
-*
-*   - `require.resolve(\`${specifier}/package.json\`)` throws
-*     `ERR_PACKAGE_PATH_NOT_EXPORTED` on packages (like `@devdogsuga/env`,
-*     `@devdogsuga/open-graph`) whose `exports` map does not list
-*     `"./package.json"`, even though the file is on disk.
-*   - A resolved path cannot be assumed to contain a literal
-*     `node_modules/<specifier>` segment — pnpm workspace-linked packages
-*     resolve to their REALPATH (e.g. `packages/open-graph/dist/index.js`),
-*     which has no such segment at all.
-*   - `require.resolve` ignores whatever `conditions` a caller has set on
-*     `tsx`'s `register()` — condition-based resolution (the
-*     `devdogs-source` condition) has to be done by hand, reading the
-*     target package's own `exports["."]` map.
-*
-* Both problems are solved the same way: walk up from the resolved file's
-* directory to the nearest `package.json` whose own `"name"` field matches
-* the specifier. That works for a real installed dependency AND a
-* workspace symlink, uniformly.
-*/
-/**
-* The installable package name a (possibly subpath) specifier belongs to:
-* `@devdogsuga/env/load` → `@devdogsuga/env`, `foo/bar` → `foo`. A repo's
-* package.json declares the PACKAGE as a dependency, never a subpath, so
-* `findDependent` has to search on this rather than the literal specifier a
-* caller wants to import.
-*/
-function packageNameOf(specifier) {
-	const parts = specifier.split("/");
-	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-}
-/**
-* Scans `apps/*` and `packages/*` under `repoRoot` for the first
-* `package.json` whose `dependencies`/`devDependencies`/`peerDependencies`
-* names `specifier`'s package (see `packageNameOf`). Returns its path
-* relative to `repoRoot`, or `null` if nothing in the repo depends on it.
-*
-* Re-scans the filesystem on every call — fine for a short-lived CLI
-* invocation calling this a handful of times; see FINDINGS item 5 if this
-* is ever called in a hot loop.
-*/
-function findDependent(repoRoot, specifier) {
-	const packageName = packageNameOf(specifier);
-	for (const group of ["apps", "packages"]) {
-		const groupDir = join(repoRoot, group);
-		let entries;
-		try {
-			entries = readdirSync(groupDir);
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			const pkgJsonPath = join(groupDir, entry, "package.json");
-			if (!existsSync(pkgJsonPath)) continue;
-			let pkg;
-			try {
-				pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-			} catch {
-				continue;
-			}
-			if (packageName in {
-				...pkg.dependencies,
-				...pkg.devDependencies,
-				...pkg.peerDependencies
-			}) return join(group, entry, "package.json");
-		}
-	}
-	return null;
-}
-/** Walks up from `startDir` to the nearest `package.json` whose `"name"` matches `specifier`. */
-function findOwningPackageJson(startDir, specifier) {
-	const packageName = packageNameOf(specifier);
-	let dir = startDir;
-	for (;;) {
-		const candidate = join(dir, "package.json");
-		if (existsSync(candidate)) try {
-			if (JSON.parse(readFileSync(candidate, "utf8")).name === packageName) return candidate;
-		} catch {}
-		const parent = dirname(dir);
-		if (parent === dir) throw new Error(`resolveFromRepo: could not find ${specifier}'s own package.json by walking up from ${startDir}`);
-		dir = parent;
-	}
-}
-/**
-* Resolves `specifier` as `resolutionBase` (a workspace-relative
-* `package.json` path known to depend on it, from `findDependent()`) would
-* see it.
-*
-* `opts.condition`, when given, is NOT passed through to Node's resolver —
-* `require.resolve` ignores tsx's `register({ conditions })` entirely (see
-* this module's header). Instead the target package's own
-* `exports["."]` map is read directly and `exports["."][condition]` is
-* picked, falling back to `.default`.
-*/
-function resolveFromRepo(repoRoot, resolutionBase, specifier, opts) {
-	const baseFile = join(repoRoot, resolutionBase);
-	const require = createRequire(baseFile);
-	let resolvedPath;
-	if (opts?.condition) {
-		const defaultEntry = require.resolve(specifier);
-		const pkgJsonPath = findOwningPackageJson(dirname(defaultEntry), specifier);
-		const rootExport = JSON.parse(readFileSync(pkgJsonPath, "utf8")).exports?.["."];
-		const conditioned = rootExport && typeof rootExport === "object" ? rootExport[opts.condition] ?? rootExport.default : void 0;
-		if (typeof conditioned !== "string") throw new Error(`resolveFromRepo: ${specifier} has no "${opts.condition}" (or "default") export in its exports["."] map`);
-		resolvedPath = join(dirname(pkgJsonPath), conditioned);
-	} else resolvedPath = require.resolve(specifier);
-	const pkgJsonPath = findOwningPackageJson(dirname(resolvedPath), specifier);
-	const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
-	return {
-		resolvedPath,
-		version: pkg.version ?? "0.0.0",
-		pkgJsonPath
-	};
-}
-//#endregion
-//#region ../cli-core/src/repo/peers.ts
-/**
-* Loads devtools' optional-peer `@devdogsuga/*` libraries — the ones
-* published to npm and consumed by the TARGET repo, which devtools reads at
-* runtime rather than bundling its own copy of (see this package's
-* `package.json`: `peerDependencies` + `peerDependenciesMeta.optional`, and
-* `FINDINGS.md` experiment 2).
-*
-* Every export here is memoized per module (one dynamic `import()` per
-* process, not per call) — this is what makes the module-identity guarantee
-* in FINDINGS experiment 3 hold: every devtools call site that needs
-* `@devdogsuga/env`'s registry gets the exact same module instance the
-* repo's own manifests populated via `declare()`/`define()`, because both
-* resolve to the identical absolute file path and Node's ESM cache is keyed
-* by resolved URL.
-*/
-const moduleCache = /* @__PURE__ */ new Map();
-/** The file URL each peer resolved to through the target repo, set only on
-*  that path (not on either plain bare-specifier fallback). See
-*  `repoPeerUrl()`. */
-const resolvedUrls = /* @__PURE__ */ new Map();
-/**
-* Dynamically imports `specifier` as the repo would resolve it, memoized so
-* repeated calls in one process return the SAME module instance (required
-* for the env-registry identity guarantee above).
-*
-* Falls back to a plain bare-specifier `import()` when devtools is not
-* running inside a DevDogsUGA checkout at all (`findRepoRoot()` throws
-* `RepoNotFoundError`). That is not a production affordance — under real
-* `pnpm dlx` use, `specifier` is an optional peer devtools' own package
-* never installs, so the fallback import fails with the ordinary
-* `MODULE_NOT_FOUND` either way. It exists so devtools' OWN test suite
-* (which has no target repo to discover, but does have every one of these
-* peers as a real Backstage workspace package) exercises this code against
-* the genuine package rather than needing every test to mock this module.
-*/
-function loadPeer(specifier) {
-	const cached = moduleCache.get(specifier);
-	if (cached) return cached;
-	const promise = (async () => {
-		if (process.env.DEVTOOLS_TEST_REPO_ROOT) return import(specifier);
-		let repoRoot;
-		try {
-			repoRoot = findRepoRoot();
-		} catch (err) {
-			if (err instanceof RepoNotFoundError) return import(specifier);
-			throw err;
-		}
-		const resolutionBase = findDependent(repoRoot, specifier);
-		if (!resolutionBase) throw new Error(`Nothing in this repo depends on ${specifier} — expected an app or package under apps/* or packages/* to declare it (dependencies/devDependencies/peerDependencies).`);
-		const { resolvedPath } = resolveFromRepo(repoRoot, resolutionBase, specifier);
-		const url = pathToFileURL(resolvedPath).href;
-		resolvedUrls.set(specifier, url);
-		return import(url);
-	})();
-	moduleCache.set(specifier, promise);
-	return promise;
-}
-/**
-* The file URL `specifier` was loaded from through the target repo, or
-* undefined if it has not been loaded yet or came from a plain bare-specifier
-* `import()` (the test-suite and not-in-a-repo fallbacks above).
-*
-* For code devtools imports that itself names a peer by bare specifier --
-* today only devtools' own `env.ts` manifest. From an installed copy that
-* specifier cannot resolve at all (an optional peer is never installed next
-* to devtools under `pnpm dlx`), and even where it can, the only copy that
-* keeps module identity is this one. `repo/peer-redirect.ts` uses it to
-* point the import here.
-*/
-function repoPeerUrl(specifier) {
-	return resolvedUrls.get(specifier);
-}
-/**
-* Like `repoPeerUrl`, but for any specifier a package of the repo you are in
-* can resolve, subpaths included (`@devdogsuga/env/nextjs`), without having
-* loaded it. Undefined outside a real repo or when nothing depends on it.
-*/
-function resolveRepoPeerUrl(specifier) {
-	const known = resolvedUrls.get(specifier);
-	if (known) return known;
-	if (process.env.DEVTOOLS_TEST_REPO_ROOT) return void 0;
-	try {
-		const repoRoot = findRepoRoot();
-		const base = findDependent(repoRoot, specifier);
-		if (!base) return void 0;
-		const { resolvedPath } = resolveFromRepo(repoRoot, base, specifier);
-		return pathToFileURL(resolvedPath).href;
-	} catch {
-		return;
-	}
-}
-let resolvedEnvModule;
-function loadEnv() {
-	return loadPeer("@devdogsuga/env").then((mod) => {
-		resolvedEnvModule = mod;
-		return mod;
-	});
-}
-/**
-* The synchronous companion to `loadEnv()`, for the handful of call sites
-* (`gh/environments.ts`'s `GITHUB_ENVIRONMENT_SPECS` getters) that cannot
-* become async without changing their own callers' contract — they read a
-* plain array off a getter, not a Promise. Safe ONLY after `loadEnv()` has
-* resolved at least once; every caller of these getters already requires
-* `env/discovery.ts`'s `loadRegistry()` (which calls `loadEnv()` itself) to
-* have run first, via `assertRegistryLoaded()`'s own guard.
-*/
-function getEnvSync() {
-	if (!resolvedEnvModule) throw new Error("getEnvSync() called before loadEnv() ever resolved — call loadRegistry() (env/discovery.ts) first.");
-	return resolvedEnvModule;
-}
-function loadEnvLoad() {
-	return loadPeer("@devdogsuga/env/load");
-}
-function loadEnvSession() {
-	return loadPeer("@devdogsuga/env/session");
-}
-//#endregion
-export { repoPeerUrl as a, devdogsugaRootOrNull as c, listApps as d, resolveAppPath as f, loadEnvSession as i, findApp as l, loadEnv as n, resolveRepoPeerUrl as o, resolveLayout as p, loadEnvLoad as r, appWorkspaceRoot as s, getEnvSync as t, layoutAt as u };

package/dist/root-CjPWNkBu.js

@@ -1,99 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-//#region ../cli-core/src/version.ts
-let cachedOwnDir;
-/** The published package's own root: the nearest directory above this
-* module's file that holds a `package.json`. A bundled CLI runs from a flat
-* `dist/`, so that is the CLI's root (`dist/launch.js` -> up one); the core
-* is inlined into it, so its own source location never matters at run time.
-* Memoized since it never changes within a process. */
-function ownPackageDir() {
-	if (cachedOwnDir !== void 0) return cachedOwnDir;
-	let dir = dirname(fileURLToPath(import.meta.url));
-	while (!existsSync(join(dir, "package.json")) && dirname(dir) !== dir) dir = dirname(dir);
-	cachedOwnDir = dir;
-	return dir;
-}
-/** Reads this build's own `package.json` version — used by `telemetry.ts`
-* (release tagging) and the CLI's `version` command. */
-function ownVersion() {
-	const pkg = JSON.parse(readFileSync(join(ownPackageDir(), "package.json"), "utf8"));
-	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
-}
-//#endregion
-//#region ../cli-core/src/repo/root.ts
-/**
-* Where devtools finds the DevDogsUGA checkout it is running against.
-*
-* devtools used to live inside `packages/devtools` of that repo, so its own
-* `import.meta.url` WAS a path into the repo (`PROJECT_ROOT` /
-* `REPO_ROOT` walked up a fixed number of `..` segments from this file).
-* Published as its own package and run through `pnpm dlx`, that assumption
-* breaks: this file's `import.meta.url` points into a dlx cache directory
-* or an isolated `node_modules` tree that has nothing to do with the repo
-* the contributor is standing in.
-*
-* So repo discovery walks up from `process.cwd()` instead, looking for the
-* marker validated in the `devtools-dlx` prototype
-* (`/home/sloan/scratchpad/devdogs/prototypes/devtools-dlx/FINDINGS.md`,
-* experiment 1): a directory containing `pnpm-workspace.yaml` AND whose
-* `package.json` has `"name": "devdogs-monorepo"` (DevDogsUGA) or
-* `"backstage"` (Backstage, which the CLIs also run from; `layout.ts` says
-* what differs). The name check is not redundant — a bare
-* `pnpm-workspace.yaml` matches any pnpm workspace, which devtools should
-* refuse rather than silently "find".
-*/
-/**
-* The `package.json` names a repo root may carry: DevDogsUGA's, and Backstage's
-* (the CLIs run from both; see `layout.ts`).
-*/
-const REPO_MARKER_NAMES = ["devdogs-monorepo", "backstage"];
-var RepoNotFoundError = class extends Error {
-	constructor() {
-		super("run this from inside a DevDogsUGA clone");
-		this.name = "RepoNotFoundError";
-	}
-};
-function looksLikeRepoRoot(dir) {
-	if (!existsSync(join(dir, "pnpm-workspace.yaml"))) return false;
-	try {
-		const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-		return REPO_MARKER_NAMES.includes(pkg.name);
-	} catch {
-		return false;
-	}
-}
-/**
-* Walks up from `startDir` (default `process.cwd()`) looking for the repo
-* marker. Returns `null` rather than throwing — `findRepoRoot()` below is
-* the throwing convenience most callers want; this is exported for callers
-* (like `setup`) that need to know without failing.
-*/
-function discoverRepoRoot(startDir = process.cwd()) {
-	let dir = startDir;
-	for (;;) {
-		if (looksLikeRepoRoot(dir)) return dir;
-		const parent = dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-let cachedRoot;
-/**
-* The memoized, throwing repo-root lookup. Lazy on purpose: importing this
-* module must never fail just because nothing has called it yet (`setup`
-* and `completions` in `launch.ts` never need a repo at all, and must stay
-* that way — see that file's header comment on why).
-*
-* Resolved once per process: `process.cwd()` does not change mid-invocation
-* for this CLI, and re-walking the filesystem on every call would be pure
-* waste.
-*/
-function findRepoRoot() {
-	if (cachedRoot === void 0) cachedRoot = process.env.DEVTOOLS_TEST_REPO_ROOT ?? discoverRepoRoot();
-	if (cachedRoot === null) throw new RepoNotFoundError();
-	return cachedRoot;
-}
-//#endregion
-export { ownVersion as a, ownPackageDir as i, discoverRepoRoot as n, findRepoRoot as r, RepoNotFoundError as t };

package/dist/stack-o1Kml3V0.js

@@ -1,2 +0,0 @@
-import { t as runStackCommand } from "./stack-C_50FafG.js";
-export { runStackCommand };