@dbx-tools/core 0.3.43 → 0.4.0

package/lib/src/project.js

@@ -0,0 +1,274 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { hash, json, net, string } from "@dbx-tools/shared-core";
+import { statSync as stat } from "./file.js";
+const ROOT_MARKERS = [
+    ".projenrc.ts",
+    ".projenrc.js",
+    ".projenrc.mjs",
+    ".projenrc.cjs",
+    "package.json",
+];
+/**
+ * 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 = stat(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 { cwd, output, path: pathStats ? output : undefined, pathStats, url };
+    }
+    return { cwd, output };
+}
+/**
+ * `parseCommand`, memoized per `(command, args, cwd)` - stores the whole
+ * {@link ProjectContext}. The cache key is a stable {@link hash.fnvHash} of that
+ * tuple (order-sensitive over `args`), so `cwd` is part of the key and a lookup
+ * in another directory can't collide with the default-cwd entry.
+ */
+const parsedCommandCache = new Map();
+function projectContextCommand(command, args, cwd) {
+    const processCwd = resolve(process.cwd());
+    let cacheEnabled;
+    if (!cwd) {
+        cwd = processCwd;
+        cacheEnabled = true;
+    }
+    else {
+        cwd = resolve(cwd);
+        if (cwd == processCwd) {
+            cacheEnabled = true;
+        }
+        else {
+            cacheEnabled = false;
+        }
+    }
+    const cacheKey = cacheEnabled ? hash.fnvHash(command, args) : undefined;
+    const cacheHit = cacheKey ? parsedCommandCache.get(cacheKey) : undefined;
+    if (cacheHit?.cwd === cwd) {
+        return cacheHit;
+    }
+    const result = projectContextCommandOutput(command, args, cwd);
+    if (cacheKey) {
+        parsedCommandCache.set(cacheKey, result);
+    }
+    return result;
+}
+function npmRoot(cwd) {
+    const parsed = projectContextCommand("npm", ["prefix"], cwd);
+    return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+}
+function gitRoot(cwd) {
+    const parsed = projectContextCommand("git", ["rev-parse", "--show-toplevel"], cwd);
+    return parsed.pathStats?.isDirectory() ? parsed.path : undefined;
+}
+export function root(cwd = process.cwd()) {
+    let current = resolve(cwd);
+    if (!stat(current)?.isDirectory()) {
+        current = dirname(current);
+    }
+    const boundaries = new Set([npmRoot(cwd), gitRoot(cwd)]
+        .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 (stat(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 = process.cwd()) {
+    const base = resolve(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 (stat(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 = process.cwd()) {
+    let last;
+    for (const dir of resolveProjectRoots(cwd)) {
+        if (stat(resolve(dir, "package.json"))?.isFile())
+            return dir;
+        last = dir;
+    }
+    return last ?? resolve(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 = process.cwd()) {
+    const rootDir = workspaceRoot(cwd);
+    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 string.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`. Both underlying commands are cached per `cwd` via
+ * {@link projectContextCommand}.
+ *
+ * @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 = process.cwd(), format = "https") {
+    const https = repositoryUrlFromGh(cwd) ?? repositoryUrlFromGit(cwd);
+    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.
+ * Cached per `cwd` via {@link projectContextCommand}.
+ */
+export function npmRegistry(cwd) {
+    const out = projectContextCommand("npm", ["config", "get", "registry"], cwd).output;
+    const trimmed = out?.trim();
+    return trimmed && trimmed !== "undefined" ? (net.urlBuilder(trimmed) ?? undefined) : undefined;
+}
+function readPackageName(pkgPath) {
+    if (!stat(pkgPath)?.isFile())
+        return undefined;
+    return string.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(process.cwd(), "npm"));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.js","sourceRoot":"","sources":["../../src/project.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,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,QAAQ,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,YAAY,GAAG;IACnB,cAAc;IACd,cAAc;IACd,eAAe;IACf,eAAe;IACf,cAAc;CACN,CAAC;AAkBX;;;;;;;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,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;IAC/C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC/B,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,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC/E,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC;AACzB,CAAC;AAED;;;;;GAKG;AACH,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAA0B,CAAC;AAE7D,SAAS,qBAAqB,CAAC,OAAe,EAAE,IAAc,EAAE,GAAY;IAC1E,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1C,IAAI,YAAqB,CAAC;IAC1B,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,GAAG,GAAG,UAAU,CAAC;QACjB,YAAY,GAAG,IAAI,CAAC;IACtB,CAAC;SAAM,CAAC;QACN,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QACnB,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;YACtB,YAAY,GAAG,IAAI,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,YAAY,GAAG,KAAK,CAAC;QACvB,CAAC;IACH,CAAC;IACD,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,IAAI,QAAQ,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,MAAM,GAAG,2BAA2B,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;IAC/D,IAAI,QAAQ,EAAE,CAAC;QACb,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,OAAO,CAAC,GAAY;IAC3B,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7D,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,MAAM,GAAG,qBAAqB,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,iBAAiB,CAAC,EAAE,GAAG,CAAC,CAAC;IACnF,OAAO,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,MAAc,OAAO,CAAC,GAAG,EAAE;IAC9C,IAAI,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAE3B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,EAAE,EAAE,CAAC;QAClC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IACD,MAAM,UAAU,GAAG,IAAI,GAAG,CACxB,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;SACzB,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,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;gBAC1C,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,MAAc,OAAO,CAAC,GAAG,EAAE;IAC9D,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC1B,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,IAAI,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE;YAAE,MAAM,GAAG,CAAC;IAC1C,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,CAAC;AAClC,CAAC;AAED,8FAA8F;AAC9F,SAAS,aAAa,CAAC,MAAc,OAAO,CAAC,GAAG,EAAE;IAChD,IAAI,IAAwB,CAAC;IAC7B,KAAK,MAAM,GAAG,IAAI,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE;YAAE,OAAO,GAAG,CAAC;QAC7D,IAAI,GAAG,GAAG,CAAC;IACb,CAAC;IACD,OAAO,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,MAAc,OAAO,CAAC,GAAG,EAAE;IAC9C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAEnC,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,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC;AACpE,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,CAC3B,MAAc,OAAO,CAAC,GAAG,EAAE,EAC3B,SAA0B,OAAO;IAEjC,MAAM,KAAK,GAAG,mBAAmB,CAAC,GAAG,CAAC,IAAI,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACpE,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;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,GAAY;IACtC,MAAM,GAAG,GAAG,qBAAqB,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC;IACpF,MAAM,OAAO,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC;IAC5B,OAAO,OAAO,IAAI,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACjG,CAAC;AAED,SAAS,eAAe,CAAC,OAAe;IACtC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE;QAAE,OAAO,SAAS,CAAC;IAC/C,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,SAAS,CAAC;AAC/F,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,OAAO,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;AAC5E,CAAC","sourcesContent":["import { spawnSync } from \"node:child_process\";\nimport { Stats, readFileSync } from \"node:fs\";\nimport { basename, dirname, join, resolve } from \"node:path\";\nimport { hash, json, net, string } from \"@dbx-tools/shared-core\";\nimport { statSync as stat } from \"./file\";\n\nconst ROOT_MARKERS = [\n  \".projenrc.ts\",\n  \".projenrc.js\",\n  \".projenrc.mjs\",\n  \".projenrc.cjs\",\n  \"package.json\",\n] as const;\n\n/** A command's stdout, classified as a filesystem path and/or a URL. */\nexport interface ProjectContext {\n  readonly cwd: string;\n  readonly output: string;\n  /** `output` when it names something on disk. */\n  readonly path?: string;\n  /** `fs.stat` 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 = stat(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 { cwd, output, path: pathStats ? output : undefined, pathStats, url };\n  }\n  return { cwd, output };\n}\n\n/**\n * `parseCommand`, memoized per `(command, args, cwd)` - stores the whole\n * {@link ProjectContext}. The cache key is a stable {@link hash.fnvHash} of that\n * tuple (order-sensitive over `args`), so `cwd` is part of the key and a lookup\n * in another directory can't collide with the default-cwd entry.\n */\nconst parsedCommandCache = new Map<string, ProjectContext>();\n\nfunction projectContextCommand(command: string, args: string[], cwd?: string): ProjectContext {\n  const processCwd = resolve(process.cwd());\n  let cacheEnabled: boolean;\n  if (!cwd) {\n    cwd = processCwd;\n    cacheEnabled = true;\n  } else {\n    cwd = resolve(cwd);\n    if (cwd == processCwd) {\n      cacheEnabled = true;\n    } else {\n      cacheEnabled = false;\n    }\n  }\n  const cacheKey = cacheEnabled ? hash.fnvHash(command, args) : undefined;\n  const cacheHit = cacheKey ? parsedCommandCache.get(cacheKey) : undefined;\n  if (cacheHit?.cwd === cwd) {\n    return cacheHit;\n  }\n  const result = projectContextCommandOutput(command, args, cwd);\n  if (cacheKey) {\n    parsedCommandCache.set(cacheKey, result);\n  }\n  return result;\n}\n\nfunction npmRoot(cwd?: string): string | undefined {\n  const parsed = projectContextCommand(\"npm\", [\"prefix\"], cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nfunction gitRoot(cwd?: string): string | undefined {\n  const parsed = projectContextCommand(\"git\", [\"rev-parse\", \"--show-toplevel\"], cwd);\n  return parsed.pathStats?.isDirectory() ? parsed.path : undefined;\n}\n\nexport function root(cwd: string = process.cwd()): string | undefined {\n  let current = resolve(cwd);\n\n  if (!stat(current)?.isDirectory()) {\n    current = dirname(current);\n  }\n  const boundaries = new Set(\n    [npmRoot(cwd), gitRoot(cwd)]\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 (stat(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 = process.cwd()): Generator<string> {\n  const base = resolve(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 (stat(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 = process.cwd()): string {\n  let last: string | undefined;\n  for (const dir of resolveProjectRoots(cwd)) {\n    if (stat(resolve(dir, \"package.json\"))?.isFile()) return dir;\n    last = dir;\n  }\n  return last ?? resolve(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 = process.cwd()): string {\n  const rootDir = workspaceRoot(cwd);\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 string.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`. Both underlying commands are cached per `cwd` via\n * {@link projectContextCommand}.\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(\n  cwd: string = process.cwd(),\n  format: \"https\" | \"npm\" = \"https\",\n): string | undefined {\n  const https = repositoryUrlFromGh(cwd) ?? repositoryUrlFromGit(cwd);\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 * Cached per `cwd` via {@link projectContextCommand}.\n */\nexport function npmRegistry(cwd?: string): net.UrlBuilder | undefined {\n  const out = projectContextCommand(\"npm\", [\"config\", \"get\", \"registry\"], cwd).output;\n  const trimmed = out?.trim();\n  return trimmed && trimmed !== \"undefined\" ? (net.urlBuilder(trimmed) ?? undefined) : undefined;\n}\n\nfunction readPackageName(pkgPath: string): string | undefined {\n  if (!stat(pkgPath)?.isFile()) return undefined;\n  return string.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(process.cwd(), \"npm\"));\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/brand.ts","../src/exec.ts","../src/file.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -12,23 +12,27 @@
   },
   "dependencies": {
     "yaml": "^2.9.0",
-    "@dbx-tools/shared-core": "0.3.43"
+    "@dbx-tools/shared-core": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.43",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [