@dbx-tools/core 0.9.4 → 0.9.6

package/lib/src/project-utils.js

@@ -0,0 +1,296 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { json, net, stringUtils } from "@dbx-tools/shared-core";
+import { statSync as fileStatSync } from "./file.js";
+const ROOT_MARKERS = [
+    ".projenrc.ts",
+    ".projenrc.js",
+    ".projenrc.mjs",
+    ".projenrc.cjs",
+    "package.json",
+];
+/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */
+export function resolveWorkingDirectory(cwd) {
+    return resolve(stringUtils.trimToNull(cwd) ?? process.cwd());
+}
+/**
+ * because this is crucial do not use exec.spawnSync
+ *
+ * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when
+ * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it
+ * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit
+ * or empty output.
+ */
+function projectContextCommandOutput(command, args, cwd) {
+    const result = spawnSync(command, args, { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    const output = result?.stdout?.toString()?.trim();
+    if (result.status === 0 && output) {
+        const pathStats = fileStatSync(output);
+        // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise
+        // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->
+        // `http://localhost/…`), which would mislabel directory outputs and bare
+        // tokens - so gate on the raw output already carrying a scheme + authority.
+        const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(output) ? net.urlBuilder(output) : undefined;
+        return { output, path: pathStats ? output : undefined, pathStats, url };
+    }
+    return { output };
+}
+const projectCommandCache = new Map();
+function projectContextCommand(command, args, cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    const key = resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;
+    if (key !== undefined) {
+        const cached = projectCommandCache.get(key);
+        if (cached !== undefined)
+            return cached;
+    }
+    const value = projectContextCommandOutput(command, args, resolved);
+    if (key !== undefined)
+        projectCommandCache.set(key, value);
+    return value;
+}
+function commandRoot(command, args, cwd) {
+    const parsed = projectContextCommand(command, args, cwd);
+    return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+}
+function npmRoot(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    return commandRoot("npm", ["prefix"], resolved);
+}
+function gitRoot(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    return commandRoot("git", ["rev-parse", "--show-toplevel"], resolved);
+}
+/** Resolve the nearest project root without walking above its npm or Git boundary. */
+export function root(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    let current = resolved;
+    if (!fileStatSync(current)?.isDirectory()) {
+        current = dirname(current);
+    }
+    const boundaries = new Set([npmRoot(resolved), gitRoot(resolved)]
+        .filter((path) => path !== undefined)
+        .map((path) => resolve(path)));
+    const hasBoundary = boundaries.size > 0;
+    let best;
+    while (true) {
+        for (const [priority, marker] of ROOT_MARKERS.entries()) {
+            if (fileStatSync(join(current, marker))?.isFile()) {
+                if (best === undefined ||
+                    priority < best.priority ||
+                    (priority === best.priority && current.length < best.dir.length)) {
+                    best = { dir: current, priority };
+                }
+                break;
+            }
+        }
+        if (!hasBoundary && best) {
+            return best.dir;
+        }
+        if (boundaries.has(current)) {
+            return best?.dir;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return best?.dir;
+        }
+        current = parent;
+    }
+}
+/**
+ * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and
+ * return the repo segment, stripping any `.git` suffix. Returns `undefined` for
+ * empty or unparsable input.
+ */
+export function parseGitRemote(url) {
+    const trimmed = url.trim();
+    if (!trimmed)
+        return undefined;
+    const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);
+    if (scp)
+        return lastPathSegment(scp[1] ?? "");
+    try {
+        const normalized = trimmed.replace(/\.git$/i, "");
+        const pathname = new URL(normalized).pathname;
+        const segment = pathname.split("/").filter(Boolean).at(-1);
+        return segment ? lastPathSegment(segment) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function lastPathSegment(path) {
+    const segment = path.split("/").filter(Boolean).at(-1) ?? path;
+    return segment.replace(/\.git$/i, "");
+}
+/**
+ * Yield candidate project-root directories for `cwd`, in priority order: the
+ * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;
+ * only existing directories are yielded (except the final `cwd` fallback).
+ */
+export function* resolveProjectRoots(cwd) {
+    const base = resolveWorkingDirectory(cwd);
+    const seen = new Set();
+    for (const candidate of [npmRoot(base), gitRoot(base)]) {
+        if (!candidate)
+            continue;
+        const dir = resolve(candidate);
+        if (seen.has(dir))
+            continue;
+        seen.add(dir);
+        if (fileStatSync(dir)?.isDirectory())
+            yield dir;
+    }
+    if (!seen.has(base))
+        yield base;
+}
+/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */
+function workspaceRoot(cwd) {
+    let last;
+    for (const dir of resolveProjectRoots(cwd)) {
+        if (fileStatSync(resolve(dir, "package.json"))?.isFile())
+            return dir;
+        last = dir;
+    }
+    return last ?? resolveWorkingDirectory(cwd);
+}
+/**
+ * Resolve a human-friendly project name for the repo rooted at `cwd`:
+ * `package.json` `name`, then the git remote's repo name, then the root
+ * directory's basename.
+ */
+export function name(cwd) {
+    const resolved = resolveWorkingDirectory(cwd);
+    const rootDir = workspaceRoot(resolved);
+    const fromPackage = readPackageName(resolve(rootDir, "package.json"));
+    if (fromPackage)
+        return fromPackage;
+    const remote = projectContextCommand("git", ["-C", rootDir, "remote", "get-url", "origin"], rootDir).output;
+    const fromGit = remote ? parseGitRemote(remote) : undefined;
+    if (fromGit)
+        return fromGit;
+    return basename(rootDir);
+}
+/**
+ * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the
+ * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.
+ * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.
+ */
+function repositoryUrlFromGh(cwd) {
+    const out = projectContextCommand("gh", ["repo", "view", "--json", "url"], cwd).output;
+    return stringUtils.trimToNull(json.parseRecord(out)?.url) ?? undefined;
+}
+/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */
+function resolveSshHostName(host, cwd) {
+    const line = projectContextCommand("ssh", ["-G", host], cwd)
+        .output?.split("\n")
+        .find((l) => /^hostname\s/i.test(l.trim()));
+    const name = line?.trim().split(/\s+/)[1];
+    return name && name !== host ? name : undefined;
+}
+/**
+ * Fallback: normalize `git remote get-url origin` to a plain
+ * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /
+ * embedded-credential forms are rewritten to https, and an ssh host alias is
+ * followed to its real hostname.
+ */
+function repositoryUrlFromGit(cwd) {
+    const raw = projectContextCommand("git", ["remote", "get-url", "origin"], cwd).output;
+    if (!raw)
+        return undefined;
+    // Normalize the scheme to https at the string level first: the WHATWG `URL`
+    // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the
+    // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at
+    // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}
+    // own the structured edits (strip credentials, swap the host).
+    let https = raw.replace(/^git\+/, "");
+    const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);
+    if (scp)
+        https = `https://${scp[1]}/${scp[2]}`;
+    https = https.replace(/^(ssh|git):\/\//, "https://");
+    let builder = net.urlBuilder(https);
+    if (!builder)
+        return undefined;
+    // Drop any embedded `user[:pass]@` credentials.
+    if (builder.username || builder.password) {
+        builder = builder.with("username", "").with("password", "");
+    }
+    // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).
+    const realHost = resolveSshHostName(builder.hostname, cwd);
+    if (realHost)
+        builder = builder.with("hostname", realHost);
+    return `${builder.origin}${builder.pathname.replace(/\.git$/, "")}`;
+}
+/**
+ * The repo's canonical remote URL, or `undefined` when there is no git remote.
+ * Tries `gh repo view` first (host-accurate, no parsing), then normalizes
+ * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`
+ * reuses cached command probes; another resolved directory executes directly.
+ *
+ * @param cwd - directory to resolve from (defaults to `process.cwd()`).
+ * @param format - `"https"` (default) yields `https://host/owner/repo`;
+ *   `"npm"` yields npm's `git+https://host/owner/repo.git` form (for a
+ *   `package.json` `repository.url` that passes npm provenance).
+ */
+export function repositoryUrl(cwd, format = "https") {
+    const resolved = resolveWorkingDirectory(cwd);
+    const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);
+    if (!https)
+        return undefined;
+    return format === "npm" ? `git+${https.replace(/\.git$/, "")}.git` : https;
+}
+/**
+ * The active npm registry (`npm config get registry`) as a chainable
+ * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.
+ * A blank, null, omitted, or explicitly current `cwd` reuses the cached npm
+ * command; another resolved directory executes it directly. Environment options
+ * are evaluated on every call.
+ */
+export function npmRegistry(cwd, options) {
+    const resolved = resolveWorkingDirectory(cwd);
+    return resolveNpmRegistry(resolved, options);
+}
+function resolveNpmRegistry(cwd, options) {
+    const candidates = (function* () {
+        yield projectContextCommand("npm", ["config", "get", "registry"], cwd ?? undefined).output?.trim();
+        if (typeof process !== "undefined" && process?.env) {
+            const envKey = "npm_config_registry";
+            if (options?.envVars) {
+                yield process.env[envKey];
+                yield process.env[envKey.toUpperCase()];
+            }
+        }
+    })();
+    for (const candidate of candidates) {
+        if (candidate) {
+            const url = net.urlBuilder(candidate);
+            if (!url) {
+                continue;
+            }
+            else if (options?.overrideOnly) {
+                const npmjsRegistryUrl = "https://registry.npmjs.org";
+                const registryUrl = url.toString();
+                if (registryUrl === npmjsRegistryUrl || registryUrl.startsWith(npmjsRegistryUrl + "/")) {
+                    continue;
+                }
+            }
+            return url;
+        }
+    }
+    return undefined;
+}
+function readPackageName(pkgPath) {
+    if (!fileStatSync(pkgPath)?.isFile())
+        return undefined;
+    return stringUtils.trimToNull(json.parseRecord(readFileSync(pkgPath, "utf8"))?.name) ?? undefined;
+}
+if (import.meta.main) {
+    console.log("npm root:", npmRoot());
+    console.log("repo root:", gitRoot());
+    console.log("package root:", root());
+    console.log("project name:", name());
+    console.log("repository url:", repositoryUrl());
+    console.log("repository url (npm):", repositoryUrl(undefined, "npm"));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-utils.js","sourceRoot":"","sources":["../../src/project-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAS,YAAY,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,WAAW,CAAC;AAErD,MAAM,YAAY,GAAG;IACnB,cAAc;IACd,cAAc;IACd,eAAe;IACf,eAAe;IACf,cAAc;CACN,CAAC;AAEX,qFAAqF;AACrF,MAAM,UAAU,uBAAuB,CAAC,GAAmB;IACzD,OAAO,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;AAC/D,CAAC;AAiBD;;;;;;;GAOG;AACH,SAAS,2BAA2B,CAAC,OAAe,EAAE,IAAc,EAAE,GAAW;IAC/E,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACtF,MAAM,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC;IAClD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QACvC,0EAA0E;QAC1E,4EAA4E;QAC5E,yEAAyE;QACzE,4EAA4E;QAC5E,MAAM,GAAG,GAAG,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACzF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC1E,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,CAAC;AACpB,CAAC;AAED,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAA0B,CAAC;AAE9D,SAAS,qBAAqB,CAAC,OAAe,EAAE,IAAc,EAAE,GAAY;IAC1E,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,GAAG,GACP,QAAQ,KAAK,uBAAuB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1F,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,MAAM,GAAG,mBAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,MAAM,CAAC;IAC1C,CAAC;IACD,MAAM,KAAK,GAAG,2BAA2B,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IACnE,IAAI,GAAG,KAAK,SAAS;QAAE,mBAAmB,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC3D,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,WAAW,CAAC,OAAe,EAAE,IAAc,EAAE,GAAW;IAC/D,MAAM,MAAM,GAAG,qBAAqB,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IACzD,OAAO,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED,SAAS,OAAO,CAAC,GAAY;IAC3B,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,OAAO,WAAW,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,OAAO,CAAC,GAAY;IAC3B,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,OAAO,WAAW,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC,EAAE,QAAQ,CAAC,CAAC;AACxE,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,IAAI,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,IAAI,OAAO,GAAG,QAAQ,CAAC;IAEvB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,EAAE,CAAC;QAC1C,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CACxB,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;SACnC,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC;SACpD,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAChC,CAAC;IACF,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,GAAG,CAAC,CAAC;IACxC,IAAI,IAAmD,CAAC;IACxD,OAAO,IAAI,EAAE,CAAC;QACZ,KAAK,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;YACxD,IAAI,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;gBAClD,IACE,IAAI,KAAK,SAAS;oBAClB,QAAQ,GAAG,IAAI,CAAC,QAAQ;oBACxB,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAChE,CAAC;oBACD,IAAI,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;gBACpC,CAAC;gBACD,MAAM;YACR,CAAC;QACH,CAAC;QACD,IAAI,CAAC,WAAW,IAAI,IAAI,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC,GAAG,CAAC;QAClB,CAAC;QACD,IAAI,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,EAAE,GAAG,CAAC;QACnB,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;YACvB,OAAO,IAAI,EAAE,GAAG,CAAC;QACnB,CAAC;QACD,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAE/B,MAAM,GAAG,GAAG,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChD,IAAI,GAAG;QAAE,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAE9C,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAClD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC;QAC9C,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,OAAO,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAC/D,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,SAAS,CAAC,CAAC,mBAAmB,CAAC,GAAY;IAC/C,MAAM,IAAI,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC,SAAS;YAAE,SAAS;QACzB,MAAM,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAC5B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE;YAAE,MAAM,GAAG,CAAC;IAClD,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,CAAC;AAClC,CAAC;AAED,8FAA8F;AAC9F,SAAS,aAAa,CAAC,GAAY;IACjC,IAAI,IAAwB,CAAC;IAC7B,KAAK,MAAM,GAAG,IAAI,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3C,IAAI,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE;YAAE,OAAO,GAAG,CAAC;QACrE,IAAI,GAAG,GAAG,CAAC;IACb,CAAC;IACD,OAAO,IAAI,IAAI,uBAAuB,CAAC,GAAG,CAAC,CAAC;AAC9C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,GAAY;IAC/B,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC;IAExC,MAAM,WAAW,GAAG,eAAe,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC;IACtE,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC;IAEpC,MAAM,MAAM,GAAG,qBAAqB,CAClC,KAAK,EACL,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,EAC9C,OAAO,CACR,CAAC,MAAM,CAAC;IACT,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5D,IAAI,OAAO;QAAE,OAAO,OAAO,CAAC;IAE5B,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;AAC3B,CAAC;AAED;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,GAAY;IACvC,MAAM,GAAG,GAAG,qBAAqB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC;IACvF,OAAO,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC;AACzE,CAAC;AAED,4FAA4F;AAC5F,SAAS,kBAAkB,CAAC,IAAY,EAAE,GAAY;IACpD,MAAM,IAAI,GAAG,qBAAqB,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC;SACzD,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;SACnB,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9C,MAAM,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,OAAO,IAAI,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,GAAY;IACxC,MAAM,GAAG,GAAG,qBAAqB,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC;IACtF,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAE3B,4EAA4E;IAC5E,0EAA0E;IAC1E,+EAA+E;IAC/E,+EAA+E;IAC/E,+DAA+D;IAC/D,IAAI,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/C,IAAI,GAAG;QAAE,KAAK,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/C,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;IAErD,IAAI,OAAO,GAAG,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,gDAAgD;IAChD,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;QACzC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAC9D,CAAC;IACD,qFAAqF;IACrF,MAAM,QAAQ,GAAG,kBAAkB,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAC3D,IAAI,QAAQ;QAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAE3D,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,CAAC;AACtE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY,EAAE,SAA0B,OAAO;IAC3E,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,KAAK,GAAG,mBAAmB,CAAC,QAAQ,CAAC,IAAI,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC9E,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;AAC7E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,GAAmB,EACnB,OAAuD;IAEvD,MAAM,QAAQ,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC9C,OAAO,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AAC/C,CAAC;AAED,SAAS,kBAAkB,CACzB,GAA8B,EAC9B,OAAkE;IAElE,MAAM,UAAU,GAAG,CAAC,QAAQ,CAAC;QAC3B,MAAM,qBAAqB,CACzB,KAAK,EACL,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,EAC7B,GAAG,IAAI,SAAS,CACjB,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC;QACjB,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,EAAE,GAAG,EAAE,CAAC;YACnD,MAAM,MAAM,GAAG,qBAAqB,CAAC;YACrC,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;gBACrB,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAC1B,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;IACH,CAAC,CAAC,EAAE,CAAC;IACL,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YACtC,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,SAAS;YACX,CAAC;iBAAM,IAAI,OAAO,EAAE,YAAY,EAAE,CAAC;gBACjC,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;gBACtD,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACnC,IAAI,WAAW,KAAK,gBAAgB,IAAI,WAAW,CAAC,UAAU,CAAC,gBAAgB,GAAG,GAAG,CAAC,EAAE,CAAC;oBACvF,SAAS;gBACX,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAS,eAAe,CAAC,OAAe;IACtC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE;QAAE,OAAO,SAAS,CAAC;IACvD,OAAO,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC;AACpG,CAAC;AAED,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;IACpC,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC,CAAC;IACrC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACrC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACrC,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,aAAa,EAAE,CAAC,CAAC;IAChD,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;AACxE,CAAC","sourcesContent":["import { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { json, net, stringUtils } from \"@dbx-tools/shared-core\";\nimport { statSync as fileStatSync } from \"./file.ts\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** Resolve a blank, null, omitted, relative, or absolute cwd to an absolute path. */\nexport function resolveWorkingDirectory(cwd?: string | null): string {\n  return resolve(stringUtils.trimToNull(cwd) ?? process.cwd());\n}\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly output: string;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `file.statSync` of {@link path}, when it exists. */\n  readonly pathStats?: Stats;\n  /**\n   * `output` parsed into a chainable {@link net.UrlBuilder}, when it is a real\n   * network URL - a non-blank scheme (not `file:`) AND a non-blank hostname.\n   * Bare paths, scp-like `git@host:...` remotes, and `file:` URLs stay unset.\n   */\n  readonly url?: net.UrlBuilder;\n}\n\n/**\n * because this is crucial do not use exec.spawnSync\n *\n * Run `command args` in `cwd` and classify its stdout: `path` + `pathStats` when\n * the output names something on disk, `url` (a {@link net.UrlBuilder}) when it\n * parses as a real network URL. Empty {@link ProjectContext} on a non-zero exit\n * or empty output.\n */\nfunction projectContextCommandOutput(command: string, args: string[], cwd: string): ProjectContext {\n  const result = spawnSync(command, args, { cwd, stdio: [\"ignore\", \"pipe\", \"ignore\"] });\n  const output = result?.stdout?.toString()?.trim();\n  if (result.status === 0 && output) {\n    const pathStats = fileStatSync(output);\n    // Only an EXPLICIT `scheme://...` counts as a URL. `urlBuilder` otherwise\n    // synthesizes one (a bare `example.com` -> `https://…`, an absolute path ->\n    // `http://localhost/…`), which would mislabel directory outputs and bare\n    // tokens - so gate on the raw output already carrying a scheme + authority.\n    const url = /^[a-z][a-z0-9+.-]*:\\/\\//i.test(output) ? net.urlBuilder(output) : undefined;\n    return { output, path: pathStats ? output : undefined, pathStats, url };\n  }\n  return { output };\n}\n\nconst projectCommandCache = new Map<string, ProjectContext>();\n\nfunction projectContextCommand(command: string, args: string[], cwd?: string): ProjectContext {\n  const resolved = resolveWorkingDirectory(cwd);\n  const key =\n    resolved === resolveWorkingDirectory() ? JSON.stringify([command, ...args]) : undefined;\n  if (key !== undefined) {\n    const cached = projectCommandCache.get(key);\n    if (cached !== undefined) return cached;\n  }\n  const value = projectContextCommandOutput(command, args, resolved);\n  if (key !== undefined) projectCommandCache.set(key, value);\n  return value;\n}\n\nfunction commandRoot(command: string, args: string[], cwd: string): string | undefined {\n  const parsed = projectContextCommand(command, args, cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nfunction npmRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return commandRoot(\"npm\", [\"prefix\"], resolved);\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return commandRoot(\"git\", [\"rev-parse\", \"--show-toplevel\"], resolved);\n}\n\n/** Resolve the nearest project root without walking above its npm or Git boundary. */\nexport function root(cwd?: string): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  let current = resolved;\n\n  if (!fileStatSync(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmRoot(resolved), gitRoot(resolved)]\n      .filter((path): path is string => path !== undefined)\n      .map((path) => resolve(path)),\n  );\n  const hasBoundary = boundaries.size > 0;\n  let best: { dir: string; priority: number } | undefined;\n  while (true) {\n    for (const [priority, marker] of ROOT_MARKERS.entries()) {\n      if (fileStatSync(join(current, marker))?.isFile()) {\n        if (\n          best === undefined ||\n          priority < best.priority ||\n          (priority === best.priority && current.length < best.dir.length)\n        ) {\n          best = { dir: current, priority };\n        }\n        break;\n      }\n    }\n    if (!hasBoundary && best) {\n      return best.dir;\n    }\n    if (boundaries.has(current)) {\n      return best?.dir;\n    }\n    const parent = dirname(current);\n    if (parent === current) {\n      return best?.dir;\n    }\n    current = parent;\n  }\n}\n\n/**\n * Parse a git remote URL (`https://...`, `git@host:owner/repo.git`, etc.) and\n * return the repo segment, stripping any `.git` suffix. Returns `undefined` for\n * empty or unparsable input.\n */\nexport function parseGitRemote(url: string): string | undefined {\n  const trimmed = url.trim();\n  if (!trimmed) return undefined;\n\n  const scp = /^[^@]+@[^:]+:(.+)$/i.exec(trimmed);\n  if (scp) return lastPathSegment(scp[1] ?? \"\");\n\n  try {\n    const normalized = trimmed.replace(/\\.git$/i, \"\");\n    const pathname = new URL(normalized).pathname;\n    const segment = pathname.split(\"/\").filter(Boolean).at(-1);\n    return segment ? lastPathSegment(segment) : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction lastPathSegment(path: string): string {\n  const segment = path.split(\"/\").filter(Boolean).at(-1) ?? path;\n  return segment.replace(/\\.git$/i, \"\");\n}\n\n/**\n * Yield candidate project-root directories for `cwd`, in priority order: the\n * `npm prefix`, the git top-level, then `cwd` itself. Duplicates are skipped;\n * only existing directories are yielded (except the final `cwd` fallback).\n */\nexport function* resolveProjectRoots(cwd?: string): Generator<string> {\n  const base = resolveWorkingDirectory(cwd);\n  const seen = new Set<string>();\n  for (const candidate of [npmRoot(base), gitRoot(base)]) {\n    if (!candidate) continue;\n    const dir = resolve(candidate);\n    if (seen.has(dir)) continue;\n    seen.add(dir);\n    if (fileStatSync(dir)?.isDirectory()) yield dir;\n  }\n  if (!seen.has(base)) yield base;\n}\n\n/** The nearest ancestor of `cwd` (from {@link resolveProjectRoots}) with a `package.json`. */\nfunction workspaceRoot(cwd?: string): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (fileStatSync(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolveWorkingDirectory(cwd);\n}\n\n/**\n * Resolve a human-friendly project name for the repo rooted at `cwd`:\n * `package.json` `name`, then the git remote's repo name, then the root\n * directory's basename.\n */\nexport function name(cwd?: string): string {\n  const resolved = resolveWorkingDirectory(cwd);\n  const rootDir = workspaceRoot(resolved);\n\n  const fromPackage = readPackageName(resolve(rootDir, \"package.json\"));\n  if (fromPackage) return fromPackage;\n\n  const remote = projectContextCommand(\n    \"git\",\n    [\"-C\", rootDir, \"remote\", \"get-url\", \"origin\"],\n    rootDir,\n  ).output;\n  const fromGit = remote ? parseGitRemote(remote) : undefined;\n  if (fromGit) return fromGit;\n\n  return basename(rootDir);\n}\n\n/**\n * The GitHub CLI's canonical repo URL - the easy path. `gh` already resolves the\n * true host (no ssh-alias parsing) and prints a clean `https://host/owner/repo`.\n * `undefined` when `gh` is absent, unauthenticated, or the dir isn't a GH repo.\n */\nfunction repositoryUrlFromGh(cwd?: string): string | undefined {\n  const out = projectContextCommand(\"gh\", [\"repo\", \"view\", \"--json\", \"url\"], cwd).output;\n  return stringUtils.trimToNull(json.parseRecord(out)?.url) ?? undefined;\n}\n\n/** Resolve an ssh host alias (`~/.ssh/config`) to its effective `hostname` via `ssh -G`. */\nfunction resolveSshHostName(host: string, cwd?: string): string | undefined {\n  const line = projectContextCommand(\"ssh\", [\"-G\", host], cwd)\n    .output?.split(\"\\n\")\n    .find((l) => /^hostname\\s/i.test(l.trim()));\n  const name = line?.trim().split(/\\s+/)[1];\n  return name && name !== host ? name : undefined;\n}\n\n/**\n * Fallback: normalize `git remote get-url origin` to a plain\n * `https://host/owner/repo` URL. scp-like / `ssh://` / `git://` /\n * embedded-credential forms are rewritten to https, and an ssh host alias is\n * followed to its real hostname.\n */\nfunction repositoryUrlFromGit(cwd?: string): string | undefined {\n  const raw = projectContextCommand(\"git\", [\"remote\", \"get-url\", \"origin\"], cwd).output;\n  if (!raw) return undefined;\n\n  // Normalize the scheme to https at the string level first: the WHATWG `URL`\n  // parser can't convert a non-special scheme (`ssh`/`git`) to `https` (the\n  // `protocol` setter no-ops), and scp-like `git@host:owner/repo` isn't a URL at\n  // all. Rewrite both into an `https://` string, then let {@link net.urlBuilder}\n  // own the structured edits (strip credentials, swap the host).\n  let https = raw.replace(/^git\\+/, \"\");\n  const scp = /^[^@]+@([^:]+):(.+)$/.exec(https);\n  if (scp) https = `https://${scp[1]}/${scp[2]}`;\n  https = https.replace(/^(ssh|git):\\/\\//, \"https://\");\n\n  let builder = net.urlBuilder(https);\n  if (!builder) return undefined;\n  // Drop any embedded `user[:pass]@` credentials.\n  if (builder.username || builder.password) {\n    builder = builder.with(\"username\", \"\").with(\"password\", \"\");\n  }\n  // Follow an ssh host alias to the true host (so `github-reggie-db` -> `github.com`).\n  const realHost = resolveSshHostName(builder.hostname, cwd);\n  if (realHost) builder = builder.with(\"hostname\", realHost);\n\n  return `${builder.origin}${builder.pathname.replace(/\\.git$/, \"\")}`;\n}\n\n/**\n * The repo's canonical remote URL, or `undefined` when there is no git remote.\n * Tries `gh repo view` first (host-accurate, no parsing), then normalizes\n * `git remote get-url origin`. A blank, omitted, or explicitly current `cwd`\n * reuses cached command probes; another resolved directory executes directly.\n *\n * @param cwd - directory to resolve from (defaults to `process.cwd()`).\n * @param format - `\"https\"` (default) yields `https://host/owner/repo`;\n *   `\"npm\"` yields npm's `git+https://host/owner/repo.git` form (for a\n *   `package.json` `repository.url` that passes npm provenance).\n */\nexport function repositoryUrl(cwd?: string, format: \"https\" | \"npm\" = \"https\"): string | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  const https = repositoryUrlFromGh(resolved) ?? repositoryUrlFromGit(resolved);\n  if (!https) return undefined;\n  return format === \"npm\" ? `git+${https.replace(/\\.git$/, \"\")}.git` : https;\n}\n\n/**\n * The active npm registry (`npm config get registry`) as a chainable\n * {@link net.UrlBuilder}, or `undefined` when npm is absent or prints no URL.\n * A blank, null, omitted, or explicitly current `cwd` reuses the cached npm\n * command; another resolved directory executes it directly. Environment options\n * are evaluated on every call.\n */\nexport function npmRegistry(\n  cwd?: string | null,\n  options?: { overrideOnly?: boolean; envVars?: boolean },\n): net.UrlBuilder | undefined {\n  const resolved = resolveWorkingDirectory(cwd);\n  return resolveNpmRegistry(resolved, options);\n}\n\nfunction resolveNpmRegistry(\n  cwd: string | null | undefined,\n  options: { overrideOnly?: boolean; envVars?: boolean } | undefined,\n): net.UrlBuilder | undefined {\n  const candidates = (function* () {\n    yield projectContextCommand(\n      \"npm\",\n      [\"config\", \"get\", \"registry\"],\n      cwd ?? undefined,\n    ).output?.trim();\n    if (typeof process !== \"undefined\" && process?.env) {\n      const envKey = \"npm_config_registry\";\n      if (options?.envVars) {\n        yield process.env[envKey];\n        yield process.env[envKey.toUpperCase()];\n      }\n    }\n  })();\n  for (const candidate of candidates) {\n    if (candidate) {\n      const url = net.urlBuilder(candidate);\n      if (!url) {\n        continue;\n      } else if (options?.overrideOnly) {\n        const npmjsRegistryUrl = \"https://registry.npmjs.org\";\n        const registryUrl = url.toString();\n        if (registryUrl === npmjsRegistryUrl || registryUrl.startsWith(npmjsRegistryUrl + \"/\")) {\n          continue;\n        }\n      }\n      return url;\n    }\n  }\n  return undefined;\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!fileStatSync(pkgPath)?.isFile()) return undefined;\n  return stringUtils.trimToNull(json.parseRecord(readFileSync(pkgPath, \"utf8\"))?.name) ?? undefined;\n}\n\nif (import.meta.main) {\n  console.log(\"npm root:\", npmRoot());\n  console.log(\"repo root:\", gitRoot());\n  console.log(\"package root:\", root());\n  console.log(\"project name:\", name());\n  console.log(\"repository url:\", repositoryUrl());\n  console.log(\"repository url (npm):\", repositoryUrl(undefined, \"npm\"));\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bin.ts","../src/brand.ts","../src/bundle.ts","../src/config.ts","../src/exec.ts","../src/file-lock.ts","../src/file.ts","../src/process-lock.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/bin.ts","../src/brand-files.ts","../src/bundle.ts","../src/config-utils.ts","../src/exec.ts","../src/file-lock.ts","../src/file.ts","../src/process-lock.ts","../src/project-utils.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -25,7 +25,8 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "^0.9.4",
+    "@dbx-tools/core-rs": "^0.9.6",
+    "@dbx-tools/shared-core": "^0.9.6",
     "extract-zip": "^2.0.1",
     "proper-lockfile": "^4.1.2",
     "tar": "^7.5.22",
@@ -43,10 +44,22 @@
         "types": "./lib/index.d.ts",
         "default": "./lib/index.js"
       },
+      "./bin": {
+        "types": "./lib/src/bin.d.ts",
+        "default": "./lib/src/bin.js"
+      },
+      "./exec": {
+        "types": "./lib/src/exec.d.ts",
+        "default": "./lib/src/exec.js"
+      },
+      "./project-utils": {
+        "types": "./lib/src/project-utils.d.ts",
+        "default": "./lib/src/project-utils.js"
+      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.4",
+  "version": "0.9.6",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -54,6 +67,18 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./bin": {
+      "types": "./lib/src/bin.d.ts",
+      "default": "./lib/src/bin.js"
+    },
+    "./exec": {
+      "types": "./lib/src/exec.d.ts",
+      "default": "./lib/src/exec.js"
+    },
+    "./project-utils": {
+      "types": "./lib/src/project-utils.d.ts",
+      "default": "./lib/src/project-utils.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/bin.ts

@@ -20,7 +20,7 @@ import { homedir, tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { promisify } from "node:util";
 
-import { error, log } from "@dbx-tools/shared-core";
+import { errorUtils, log } from "@dbx-tools/shared-core";
 import extractZip from "extract-zip";
 import { x as extractTar } from "tar";
 
@@ -193,7 +193,7 @@ async function isValidBin(path: string, options: BinOptions): Promise<boolean> {
   } catch (cause) {
     logger.debug("binary version command failed", {
       path,
-      error: error.errorMessage(cause),
+      error: errorUtils.errorMessage(cause),
     });
     return false;
   }

package/src/{brand.ts → brand-files.ts}

@@ -1,9 +1,9 @@
 /** Node-only discovery and file loading for the shared brand context. */
 import { readFile } from "node:fs/promises";
 import { dirname, extname, isAbsolute, resolve } from "node:path";
-import { brand as sharedBrand } from "@dbx-tools/shared-core";
+import { brandUtils } from "@dbx-tools/shared-core";
 import { statSync } from "./file.ts";
-import { resolveProjectRoots } from "./project.ts";
+import { resolveProjectRoots } from "./project-utils.ts";
 
 const BRAND_CONTEXT_FILES = [
   "branding/brand.yaml",
@@ -14,13 +14,13 @@ const BRAND_CONTEXT_FILES = [
   "brand.json",
 ] as const;
 
-export type BrandContext = sharedBrand.BrandContext;
-export type BrandContextInput = sharedBrand.BrandContextInput;
-export const BrandContextSchema = sharedBrand.BrandContextSchema;
-export const defaultBrandContext = sharedBrand.defaultBrandContext;
-export const parseBrandContext = sharedBrand.parseBrandContext;
-export const brandContextJsonSchema = sharedBrand.brandContextJsonSchema;
-export const brandContextPrompt = sharedBrand.brandContextPrompt;
+export type BrandContext = brandUtils.BrandContext;
+export type BrandContextInput = brandUtils.BrandContextInput;
+export const BrandContextSchema = brandUtils.BrandContextSchema;
+export const defaultBrandContext = brandUtils.defaultBrandContext;
+export const parseBrandContext = brandUtils.parseBrandContext;
+export const brandContextJsonSchema = brandUtils.brandContextJsonSchema;
+export const brandContextPrompt = brandUtils.brandContextPrompt;
 
 /** Find a conventional YAML or JSON brand file from known project roots. */
 export function findBrandContextFile(cwd: string = process.cwd()): string | undefined {
@@ -48,7 +48,7 @@ export async function loadBrandContextFile(path: string): Promise<BrandContext>
     throw new Error(`Unsupported brand context format: ${extension || "no extension"}`);
   }
 
-  return sharedBrand.parseBrandContext(input);
+  return brandUtils.parseBrandContext(input);
 }
 
 /**
@@ -57,7 +57,7 @@ export async function loadBrandContextFile(path: string): Promise<BrandContext>
  */
 export async function loadBrandContext(cwd: string = process.cwd()): Promise<BrandContext> {
   const path = findBrandContextFile(cwd);
-  return path ? loadBrandContextFile(path) : sharedBrand.defaultBrandContext;
+  return path ? loadBrandContextFile(path) : brandUtils.defaultBrandContext;
 }
 
 /** Resolve a relative asset reference against the brand file that declared it. */

package/src/bundle.ts

@@ -11,10 +11,10 @@
 
 import { opendir, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { json, object, string } from "@dbx-tools/shared-core";
+import { json, object, stringUtils } from "@dbx-tools/shared-core";
 import { spawn } from "./exec.ts";
-import { resolveWorkingDirectory } from "./project.ts";
-import { project } from "../index.ts";
+import { resolveWorkingDirectory } from "./project-utils.ts";
+import { projectUtils } from "../index.ts";
 
 const BUNDLE_FILE_NAMES = new Set(["databricks.yml", "databricks.yaml"]);
 const IGNORED_DIRECTORIES = [
@@ -166,7 +166,7 @@ async function validateBundle(
     stdout: "capture",
     stderr: "capture",
   });
-  const detail = string.trimToNull(result.stderr) ?? string.trimToNull(result.stdout);
+  const detail = stringUtils.trimToNull(result.stderr) ?? stringUtils.trimToNull(result.stdout);
   const bundleFailure =
     result.exitCode === 0
       ? undefined
@@ -205,7 +205,7 @@ function isWithinOrEqual(candidate: string, parent: string): boolean {
 if (import.meta.main) {
   const path = process.argv[2];
   if (!path) throw new Error("Usage: bun bundle.ts <path>");
-  for await (const resource of appResources(project.root()!, path)) {
+  for await (const resource of appResources(projectUtils.root()!, path)) {
     console.dir(resource, { depth: null });
   }
 }