@augment-vir/node 30.0.0

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 electrovir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @augment-vir/node
+
+## Prisma flows
+
+-   deploy to production
+    -   `prisma.migration.applyProd`
+-   update dev environment
+    -   apply migrations: `prisma.migration.applyDev`
+        -   if throws `PrismaMigrationNeededError`, prompt user for a new migration name
+            -   pass migration name to `prisma.migration.create`
+        -   if throws `PrismaResetNeededError`, reset the database with `prisma.database.resetDev`
+    -   generate client: `prisma.client.isCurrent`
+        -   if `false`, run `prisma.client.generate`

package/dist/augments/console/question.d.ts

@@ -0,0 +1,14 @@
+import { type AnyDuration } from '@date-vir/duration';
+/** Can't test requiring user input. */
+export type AskQuestionOptions = {
+    timeout: AnyDuration;
+    hideUserInput: boolean;
+};
+export declare function askQuestion(questionToAsk: string, { hideUserInput, timeout, }?: Partial<AskQuestionOptions>): Promise<string>;
+export type QuestionUntilConditionMetConfig = {
+    questionToAsk: string;
+    conditionCallback: (response: string) => boolean | Promise<boolean>;
+    invalidInputMessage: string;
+    tryCountMax?: number;
+} & Partial<AskQuestionOptions>;
+export declare function askQuestionUntilConditionMet({ questionToAsk, conditionCallback, invalidInputMessage, tryCountMax, ...options }: QuestionUntilConditionMetConfig): Promise<string>;

package/dist/augments/console/question.js

@@ -0,0 +1,63 @@
+import { log } from '@augment-vir/common';
+import { convertDuration, DurationUnit } from '@date-vir/duration';
+import { createInterface } from 'node:readline';
+const defaultAskQuestionOptions = {
+    timeout: { seconds: 60 },
+    hideUserInput: false,
+};
+export async function askQuestion(questionToAsk, { hideUserInput = defaultAskQuestionOptions.hideUserInput, timeout = defaultAskQuestionOptions.timeout, } = defaultAskQuestionOptions) {
+    const cliInterface = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    if (hideUserInput) {
+        let promptWritten = false;
+        /** _writeToOutput is not in the types OR in the Node.js documentation but is a thing. */
+        cliInterface._writeToOutput = (prompt) => {
+            if (!promptWritten) {
+                cliInterface.output.write(prompt);
+                promptWritten = true;
+            }
+        };
+    }
+    // handle killing the process
+    cliInterface.on('SIGINT', () => {
+        cliInterface.close();
+        process.stdout.write('\n');
+        process.kill(process.pid, 'SIGINT');
+    });
+    return new Promise((resolve, reject) => {
+        const timeoutMs = convertDuration(timeout, DurationUnit.Milliseconds).milliseconds;
+        const timeoutId = timeoutMs
+            ? setTimeout(() => {
+                cliInterface.close();
+                reject(new Error(`Took too long to respond (over "${Math.floor(timeoutMs / 1000)}" seconds)`));
+            }, timeoutMs)
+            : undefined;
+        process.stdout.write(questionToAsk + '\n');
+        cliInterface.question('', (response) => {
+            if (timeoutId != undefined) {
+                clearTimeout(timeoutId);
+            }
+            cliInterface.close();
+            resolve(response);
+        });
+    });
+}
+export async function askQuestionUntilConditionMet({ questionToAsk, conditionCallback, invalidInputMessage, tryCountMax = 5, ...options }) {
+    let wasConditionMet = false;
+    let retryCount = 0;
+    let response = '';
+    while (!wasConditionMet && retryCount <= tryCountMax) {
+        response = (await askQuestion(questionToAsk, options)).trim();
+        wasConditionMet = await conditionCallback(response);
+        if (!wasConditionMet) {
+            log.error(invalidInputMessage);
+        }
+        retryCount++;
+    }
+    if (retryCount > tryCountMax) {
+        throw new Error(`Max input attempts (${tryCountMax}) exceeded.`);
+    }
+    return response;
+}

package/dist/augments/docker.d.ts

@@ -0,0 +1,44 @@
+import { getContainerInfo } from '../docker/containers/container-info.js';
+import { getContainerLogs, getContainerStatus, waitUntilContainerExited, waitUntilContainerRemoved, waitUntilContainerRunning } from '../docker/containers/container-status.js';
+import { copyToContainer } from '../docker/containers/copy-to-container.js';
+import { makeEnvFlags, makePortMapFlags, makeVolumeFlags } from '../docker/containers/docker-command-inputs.js';
+import { killContainer } from '../docker/containers/kill-container.js';
+import { runContainerCommand } from '../docker/containers/run-command.js';
+import { runContainer } from '../docker/containers/run-container.js';
+import { tryOrKillContainer } from '../docker/containers/try-or-kill-container.js';
+import { isImageInLocalRegistry, removeImageFromLocalRegistry, updateImage } from '../docker/docker-image.js';
+import { isDockerRunning, startDocker } from '../docker/docker-startup.js';
+export { DockerContainerStatusEnum, type DockerContainerInfo, type DockerContainerInfoState, } from '../docker/containers/container-info.js';
+export { DockerContainerStatus, exitedDockerContainerStatuses, } from '../docker/containers/container-status.js';
+export { type CopyToDockerContainerParams } from '../docker/containers/copy-to-container.js';
+export { type DockerEnvMap, type DockerPortMap, type DockerVolumeMap, type DockerVolumeMappingType, } from '../docker/containers/docker-command-inputs.js';
+export { type RunDockerContainerCommandParams } from '../docker/containers/run-command.js';
+export { type RunDockerContainerParams } from '../docker/containers/run-container.js';
+/** Centralized Docker API from `@augment-vir/node`. */
+export declare const docker: {
+    isRunning: typeof isDockerRunning;
+    start: typeof startDocker;
+    image: {
+        update: typeof updateImage;
+        remove: typeof removeImageFromLocalRegistry;
+        exists: typeof isImageInLocalRegistry;
+    };
+    container: {
+        getStatus: typeof getContainerStatus;
+        waitUntilRunning: typeof waitUntilContainerRunning;
+        waitUntilExited: typeof waitUntilContainerExited;
+        waitUntilRemoved: typeof waitUntilContainerRemoved;
+        tryOrKill: typeof tryOrKillContainer;
+        run: typeof runContainer;
+        kill: typeof killContainer;
+        copyTo: typeof copyToContainer;
+        runCommand: typeof runContainerCommand;
+        getInfo: typeof getContainerInfo;
+        getLogs: typeof getContainerLogs;
+    };
+    util: {
+        makeVolumeFlags: typeof makeVolumeFlags;
+        makePortMapFlags: typeof makePortMapFlags;
+        makeEnvFlags: typeof makeEnvFlags;
+    };
+};

package/dist/augments/docker.js

@@ -0,0 +1,40 @@
+import { getContainerInfo } from '../docker/containers/container-info.js';
+import { getContainerLogs, getContainerStatus, waitUntilContainerExited, waitUntilContainerRemoved, waitUntilContainerRunning, } from '../docker/containers/container-status.js';
+import { copyToContainer } from '../docker/containers/copy-to-container.js';
+import { makeEnvFlags, makePortMapFlags, makeVolumeFlags, } from '../docker/containers/docker-command-inputs.js';
+import { killContainer } from '../docker/containers/kill-container.js';
+import { runContainerCommand } from '../docker/containers/run-command.js';
+import { runContainer } from '../docker/containers/run-container.js';
+import { tryOrKillContainer } from '../docker/containers/try-or-kill-container.js';
+import { isImageInLocalRegistry, removeImageFromLocalRegistry, updateImage, } from '../docker/docker-image.js';
+import { isDockerRunning, startDocker } from '../docker/docker-startup.js';
+export { DockerContainerStatusEnum, } from '../docker/containers/container-info.js';
+export { DockerContainerStatus, exitedDockerContainerStatuses, } from '../docker/containers/container-status.js';
+/** Centralized Docker API from `@augment-vir/node`. */
+export const docker = {
+    isRunning: isDockerRunning,
+    start: startDocker,
+    image: {
+        update: updateImage,
+        remove: removeImageFromLocalRegistry,
+        exists: isImageInLocalRegistry,
+    },
+    container: {
+        getStatus: getContainerStatus,
+        waitUntilRunning: waitUntilContainerRunning,
+        waitUntilExited: waitUntilContainerExited,
+        waitUntilRemoved: waitUntilContainerRemoved,
+        tryOrKill: tryOrKillContainer,
+        run: runContainer,
+        kill: killContainer,
+        copyTo: copyToContainer,
+        runCommand: runContainerCommand,
+        getInfo: getContainerInfo,
+        getLogs: getContainerLogs,
+    },
+    util: {
+        makeVolumeFlags,
+        makePortMapFlags,
+        makeEnvFlags,
+    },
+};

package/dist/augments/download.d.ts

@@ -0,0 +1,4 @@
+export declare function downloadFile({ url, writePath }: {
+    url: string;
+    writePath: string;
+}): Promise<void>;

package/dist/augments/download.js

@@ -0,0 +1,19 @@
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+export async function downloadFile({ url, writePath }) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`${response.status}: ${response.statusText}`);
+    }
+    /** Idk how to actually trigger a response with no body. */
+    /* node:coverage ignore next 3 */
+    if (!response.body) {
+        throw new Error(`Response body is missing from '${url}'.`);
+    }
+    await mkdir(dirname(writePath), { recursive: true });
+    const fileStream = createWriteStream(writePath);
+    await finished(Readable.fromWeb(response.body).pipe(fileStream));
+}

package/dist/augments/fs/json.d.ts

@@ -0,0 +1,8 @@
+import { JsonCompatibleArray, JsonCompatibleObject, type JsonCompatibleValue } from '@augment-vir/common';
+import type { PartialWithUndefined } from '@augment-vir/core';
+export declare function readJsonFile(path: string): Promise<JsonCompatibleValue | undefined>;
+export type WriteJsonOptions = PartialWithUndefined<{
+    includeTrailingNewLine: boolean;
+}>;
+export declare function writeJsonFile(path: string, data: JsonCompatibleValue, options?: WriteJsonOptions): Promise<void>;
+export declare function appendJsonFile(path: string, newData: JsonCompatibleObject | JsonCompatibleArray, options?: WriteJsonOptions): Promise<void>;

package/dist/augments/fs/json.js

@@ -0,0 +1,22 @@
+import { appendJson, } from '@augment-vir/common';
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { writeFileAndDir } from './write.js';
+export async function readJsonFile(path) {
+    try {
+        const contents = (await readFile(path)).toString();
+        return JSON.parse(contents);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function writeJsonFile(path, data, options = {}) {
+    await mkdir(dirname(path), { recursive: true });
+    const trailingNewLine = options.includeTrailingNewLine ? '\n' : '';
+    await writeFileAndDir(path, JSON.stringify(data, null, 4) + trailingNewLine);
+}
+export async function appendJsonFile(path, newData, options = {}) {
+    const fileJson = await readJsonFile(path);
+    await writeJsonFile(path, appendJson(fileJson, newData), options);
+}

package/dist/augments/fs/read-dir.d.ts

@@ -0,0 +1,16 @@
+import type { RequireExactlyOne } from 'type-fest';
+/**
+ * Gets all files within a directory and its subdirectories, recursively. Returns an array of paths
+ * relative to the input directory path.
+ */
+export declare function readDirRecursive(dirPath: string): Promise<string[]>;
+/**
+ * Reads all files within a directory and then filters them by the given extension or extensions.
+ * Returns that filtered list.
+ */
+export declare function readDirFilesByExtension({ dirPath, extension, extensions, }: {
+    dirPath: string;
+} & RequireExactlyOne<{
+    extension: string;
+    extensions: ReadonlyArray<string>;
+}>): Promise<string[]>;

package/dist/augments/fs/read-dir.js

@@ -0,0 +1,31 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+async function internalReadDirPathsRecursive(dirPath, basePath) {
+    const dirContents = await readdir(dirPath);
+    const recursiveContents = (await Promise.all(dirContents.map(async (fileName) => {
+        const filePath = join(dirPath, fileName);
+        if ((await stat(filePath)).isDirectory()) {
+            return internalReadDirPathsRecursive(filePath, basePath);
+        }
+        else {
+            return relative(basePath, filePath);
+        }
+    }))).flat();
+    return recursiveContents;
+}
+/**
+ * Gets all files within a directory and its subdirectories, recursively. Returns an array of paths
+ * relative to the input directory path.
+ */
+export async function readDirRecursive(dirPath) {
+    return await internalReadDirPathsRecursive(dirPath, dirPath);
+}
+/**
+ * Reads all files within a directory and then filters them by the given extension or extensions.
+ * Returns that filtered list.
+ */
+export async function readDirFilesByExtension({ dirPath, extension, extensions, }) {
+    const extensionsToCheck = extensions || [extension];
+    const fileNames = await readdir(dirPath);
+    return fileNames.filter((fileName) => extensionsToCheck.some((extensionToCheck) => fileName.endsWith(extensionToCheck)));
+}

package/dist/augments/fs/read-file.d.ts

@@ -0,0 +1 @@
+export declare function readFileIfExists(path: string): Promise<string | undefined>;

package/dist/augments/fs/read-file.js

@@ -0,0 +1,10 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+export async function readFileIfExists(path) {
+    if (existsSync(path)) {
+        return (await readFile(path)).toString();
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/augments/fs/symlink.d.ts

@@ -0,0 +1,9 @@
+export declare function createSymlink({ linkTo, symlinkPath, }: {
+    /**
+     * Path that the symlink will link to. If relative, it will be linked relative to the symlink
+     * location.
+     */
+    linkTo: string;
+    /** The location and name the symlink file to be created. */
+    symlinkPath: string;
+}): Promise<void>;

package/dist/augments/fs/symlink.js

@@ -0,0 +1,16 @@
+import { existsSync } from 'node:fs';
+import { lstat, readlink, stat, symlink } from 'node:fs/promises';
+export async function createSymlink({ linkTo, symlinkPath, }) {
+    if (existsSync(symlinkPath)) {
+        if (!(await lstat(symlinkPath)).isSymbolicLink()) {
+            throw new Error(`Tried to create symlink at '${symlinkPath}' but a non-symlink file already exists in that location.`);
+        }
+        else if ((await readlink(symlinkPath)) !== linkTo) {
+            throw new Error(`Symlink already exists at '${symlinkPath}' but has a differently link path.`);
+        }
+    }
+    else {
+        const isDir = (await stat(linkTo)).isDirectory();
+        await symlink(linkTo, symlinkPath, isDir ? 'dir' : 'file');
+    }
+}

package/dist/augments/fs/write.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Writes to the given file path and always ensures that the path's parent directories are all
+ * created.
+ */
+export declare function writeFileAndDir(path: string, contents: string | NodeJS.ArrayBufferView): Promise<void>;

package/dist/augments/fs/write.js

@@ -0,0 +1,10 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/**
+ * Writes to the given file path and always ensures that the path's parent directories are all
+ * created.
+ */
+export async function writeFileAndDir(path, contents) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, contents);
+}

package/dist/augments/npm/query-workspace.d.ts

@@ -0,0 +1,18 @@
+import type { UnknownObject } from '@augment-vir/core';
+import type { PackageJson } from 'type-fest';
+export type NpmWorkspace = PackageJson & {
+    _id: string;
+    deduped: boolean;
+    dev: boolean;
+    from: string[];
+    inBundle: boolean;
+    location: string;
+    overridden: boolean;
+    path: string;
+    pkgid: string;
+    queryContext: UnknownObject;
+    realpath: string;
+    resolved: null;
+    to: string[];
+};
+export declare function queryNpmWorkspace(cwd: string): Promise<NpmWorkspace[]>;

package/dist/augments/npm/query-workspace.js

@@ -0,0 +1,14 @@
+import { runShellCommand } from '../shell.js';
+export async function queryNpmWorkspace(cwd) {
+    const queryOutput = await runShellCommand('npm query .workspace', {
+        cwd,
+        rejectOnError: true,
+    });
+    try {
+        return JSON.parse(queryOutput.stdout);
+        /* node:coverage ignore next 3 */
+    }
+    catch {
+        throw new Error(`Failed to read npm workspace data for '${cwd}'`);
+    }
+}

package/dist/augments/npm/read-package-json.d.ts

@@ -0,0 +1,2 @@
+import { PackageJson } from 'type-fest';
+export declare function readPackageJson(dirPath: string): Promise<PackageJson>;

package/dist/augments/npm/read-package-json.js

@@ -0,0 +1,14 @@
+import { check } from '@augment-vir/assert';
+import { join } from 'node:path';
+import { readJsonFile } from '../fs/json.js';
+export async function readPackageJson(dirPath) {
+    const packageJsonPath = join(dirPath, 'package.json');
+    const packageJson = (await readJsonFile(packageJsonPath));
+    if (!packageJson) {
+        throw new TypeError(`package.json file does not exist in '${dirPath}'`);
+    }
+    if (!check.isObject(packageJson)) {
+        throw new TypeError(`Parsing package.json file did not return an object in '${dirPath}'`);
+    }
+    return packageJson;
+}

package/dist/augments/os/operating-system.d.ts

@@ -0,0 +1,6 @@
+export declare enum OperatingSystem {
+    Linux = "linux",
+    Mac = "mac",
+    Windows = "windows"
+}
+export declare const currentOperatingSystem: OperatingSystem;

package/dist/augments/os/operating-system.js

@@ -0,0 +1,20 @@
+export var OperatingSystem;
+(function (OperatingSystem) {
+    OperatingSystem["Linux"] = "linux";
+    OperatingSystem["Mac"] = "mac";
+    OperatingSystem["Windows"] = "windows";
+})(OperatingSystem || (OperatingSystem = {}));
+export const currentOperatingSystem = getOperatingSystem();
+function getOperatingSystem() {
+    /** We can't test all of these on a single system. */
+    /* node:coverage ignore next 7 */
+    if (process.platform === 'win32') {
+        return OperatingSystem.Windows;
+    }
+    else if (process.platform === 'darwin') {
+        return OperatingSystem.Mac;
+    }
+    else {
+        return OperatingSystem.Linux;
+    }
+}

package/dist/augments/path/ancestor.d.ts

@@ -0,0 +1,5 @@
+import type { MaybePromise } from '@augment-vir/common';
+export declare function findAncestor(currentPath: string, callback: (path: string) => Promise<boolean>): Promise<string | undefined>;
+export declare function findAncestor(currentPath: string, callback: (path: string) => boolean): string | undefined;
+export declare function findAncestor(currentPath: string, callback: (path: string) => MaybePromise<boolean>): MaybePromise<string | undefined>;
+export declare function joinFilesToDir(parentDirPath: string, childNames: ReadonlyArray<string>): Array<string>;

package/dist/augments/path/ancestor.js

@@ -0,0 +1,29 @@
+import { check } from '@augment-vir/assert';
+import { dirname, join } from 'node:path';
+import { systemRootPath } from './root.js';
+export function findAncestor(currentPath, callback) {
+    if (currentPath === systemRootPath) {
+        return undefined;
+    }
+    const result = callback(currentPath);
+    if (check.isPromise(result)) {
+        return new Promise(async (resolve) => {
+            const awaitedResult = await result;
+            if (awaitedResult) {
+                resolve(currentPath);
+            }
+            else {
+                resolve(await findAncestor(dirname(currentPath), callback));
+            }
+        });
+    }
+    else if (result) {
+        return currentPath;
+    }
+    else {
+        return findAncestor(dirname(currentPath), callback);
+    }
+}
+export function joinFilesToDir(parentDirPath, childNames) {
+    return childNames.map((childName) => join(parentDirPath, childName));
+}

package/dist/augments/path/os-path.d.ts

@@ -0,0 +1,9 @@
+/** Convert a given path to a windows path if the current system doesn't use `/`. */
+export declare function replaceWithWindowsPathIfNeeded(input: string): string;
+/** Convert a Windows path to a posix path. */
+export declare function toPosixPath(maybeWindowsPath: string): string;
+/**
+ * Use this to interpolate paths into bash commands. If the given path is not a window path, the
+ * path structure will not be modified.
+ */
+export declare function interpolationSafeWindowsPath(input: string): string;