@cbnventures/nova 0.14.0 → 0.15.1

package/build/src/lib/utility.d.ts

@@ -1,19 +1,22 @@
-import type { CurrentTimestampReturns, DetectShellReturns, DiscoverPathsWithFileDirection, DiscoverPathsWithFileFileName, DiscoverPathsWithFileReturns, ExecuteShellCommand, ExecuteShellReturns, IsCommandExistsCommand, IsCommandExistsReturns, IsExecuteShellErrorError, IsExecuteShellErrorTypeGuard, IsFileIdenticalExistingFilePath, IsFileIdenticalProposedContents, IsFileIdenticalReturns, IsPlainObjectTypeGuard, IsPlainObjectValue, IsProjectRootCurrentDirectory, IsProjectRootReturns, LoadWorkspaceManifestsOptions, LoadWorkspaceManifestsReturns, ParseLinuxOsReleaseFileReturns, ParseLinuxOsReleaseTextReturns, ParseLinuxOsReleaseTextText, ParseWindowsRegistryQueryRegistryPaths, ParseWindowsRegistryQueryReturns, ParseWindowsRegistryTextReturns, ParseWindowsRegistryTextText, PathExistsPath, PathExistsReturns, RenameFileWithDateOldPath, RenameFileWithDatePrefix, RenameFileWithDateReturns, RenameFileWithDateSuffix, SaveWorkspaceManifestReplaceFile, SaveWorkspaceManifestReturns, SaveWorkspaceManifestWorkspace } from '../types/lib/utility.d.ts';
-export declare function currentTimestamp(): CurrentTimestampReturns;
-export declare function detectShell(): DetectShellReturns;
-export declare function discoverPathsWithFile(fileName: DiscoverPathsWithFileFileName, direction: DiscoverPathsWithFileDirection): DiscoverPathsWithFileReturns;
-export declare function executeShell(command: ExecuteShellCommand): ExecuteShellReturns;
-export declare function isCommandExists(command: IsCommandExistsCommand): IsCommandExistsReturns;
-export declare function isExecuteShellError(error: IsExecuteShellErrorError): error is IsExecuteShellErrorTypeGuard;
-export declare function isFileIdentical(existingFilePath: IsFileIdenticalExistingFilePath, proposedContents: IsFileIdenticalProposedContents): IsFileIdenticalReturns;
-export declare function isPlainObject(value: IsPlainObjectValue): value is IsPlainObjectTypeGuard;
-export declare function isProjectRoot(currentDirectory: IsProjectRootCurrentDirectory): IsProjectRootReturns;
-export declare function loadWorkspaceManifests(options: LoadWorkspaceManifestsOptions): LoadWorkspaceManifestsReturns;
-export declare function parseLinuxOsReleaseFile(): ParseLinuxOsReleaseFileReturns;
-export declare function parseLinuxOsReleaseText(text: ParseLinuxOsReleaseTextText): ParseLinuxOsReleaseTextReturns;
-export declare function parseWindowsRegistryQuery(registryPaths: ParseWindowsRegistryQueryRegistryPaths): ParseWindowsRegistryQueryReturns;
-export declare function parseWindowsRegistryText(text: ParseWindowsRegistryTextText): ParseWindowsRegistryTextReturns;
-export declare function pathExists(path: PathExistsPath): PathExistsReturns;
-export declare function renameFileWithDate(oldPath: RenameFileWithDateOldPath, prefix: RenameFileWithDatePrefix, suffix: RenameFileWithDateSuffix): RenameFileWithDateReturns;
-export declare function saveWorkspaceManifest(workspace: SaveWorkspaceManifestWorkspace, replaceFile: SaveWorkspaceManifestReplaceFile): SaveWorkspaceManifestReturns;
+import type { LibUtilityCurrentTimestampReturns, LibUtilityDetectShellReturns, LibUtilityDiscoverPathsWithFileDirection, LibUtilityDiscoverPathsWithFileFileName, LibUtilityDiscoverPathsWithFileReturns, LibUtilityExecuteShellCommand, LibUtilityExecuteShellReturns, LibUtilityIsCommandExistsCommand, LibUtilityIsCommandExistsReturns, LibUtilityIsExecuteShellErrorError, LibUtilityIsExecuteShellErrorTypeGuard, LibUtilityIsFileIdenticalExistingFilePath, LibUtilityIsFileIdenticalProposedContents, LibUtilityIsFileIdenticalReturns, LibUtilityIsIgnoredFileFilename, LibUtilityIsIgnoredFileIgnoreFiles, LibUtilityIsIgnoredFileReturns, LibUtilityIsPlainObjectTypeGuard, LibUtilityIsPlainObjectValue, LibUtilityIsProjectRootCurrentDirectory, LibUtilityIsProjectRootReturns, LibUtilityLoadWorkspaceManifestsOptions, LibUtilityLoadWorkspaceManifestsReturns, LibUtilityParseLinuxOsReleaseFileReturns, LibUtilityParseLinuxOsReleaseTextReturns, LibUtilityParseLinuxOsReleaseTextText, LibUtilityParseWindowsRegistryQueryRegistryPaths, LibUtilityParseWindowsRegistryQueryReturns, LibUtilityParseWindowsRegistryTextReturns, LibUtilityParseWindowsRegistryTextText, LibUtilityPathExistsPath, LibUtilityPathExistsReturns, LibUtilityRenameFileWithDateOldPath, LibUtilityRenameFileWithDateReturns, LibUtilityResolveTemplatePathImportMetaUrl, LibUtilityResolveTemplatePathReturns, LibUtilityResolveTemplatePathSubpath, LibUtilitySaveGeneratedFileContents, LibUtilitySaveGeneratedFileReplaceFile, LibUtilitySaveGeneratedFileReturns, LibUtilitySaveGeneratedFileTargetPath, LibUtilitySaveWorkspaceManifestReplaceFile, LibUtilitySaveWorkspaceManifestReturns, LibUtilitySaveWorkspaceManifestWorkspace } from '../types/lib/utility.d.ts';
+export declare function currentTimestamp(): LibUtilityCurrentTimestampReturns;
+export declare function detectShell(): LibUtilityDetectShellReturns;
+export declare function discoverPathsWithFile(fileName: LibUtilityDiscoverPathsWithFileFileName, direction: LibUtilityDiscoverPathsWithFileDirection): LibUtilityDiscoverPathsWithFileReturns;
+export declare function executeShell(command: LibUtilityExecuteShellCommand): LibUtilityExecuteShellReturns;
+export declare function isCommandExists(command: LibUtilityIsCommandExistsCommand): LibUtilityIsCommandExistsReturns;
+export declare function isExecuteShellError(error: LibUtilityIsExecuteShellErrorError): error is LibUtilityIsExecuteShellErrorTypeGuard;
+export declare function isFileIdentical(existingFilePath: LibUtilityIsFileIdenticalExistingFilePath, proposedContents: LibUtilityIsFileIdenticalProposedContents): LibUtilityIsFileIdenticalReturns;
+export declare function isIgnoredFile(filename: LibUtilityIsIgnoredFileFilename, ignoreFiles: LibUtilityIsIgnoredFileIgnoreFiles): LibUtilityIsIgnoredFileReturns;
+export declare function isPlainObject(value: LibUtilityIsPlainObjectValue): value is LibUtilityIsPlainObjectTypeGuard;
+export declare function isProjectRoot(currentDirectory: LibUtilityIsProjectRootCurrentDirectory): LibUtilityIsProjectRootReturns;
+export declare function loadWorkspaceManifests(options: LibUtilityLoadWorkspaceManifestsOptions): LibUtilityLoadWorkspaceManifestsReturns;
+export declare function parseLinuxOsReleaseFile(): LibUtilityParseLinuxOsReleaseFileReturns;
+export declare function parseLinuxOsReleaseText(text: LibUtilityParseLinuxOsReleaseTextText): LibUtilityParseLinuxOsReleaseTextReturns;
+export declare function parseWindowsRegistryQuery(registryPaths: LibUtilityParseWindowsRegistryQueryRegistryPaths): LibUtilityParseWindowsRegistryQueryReturns;
+export declare function parseWindowsRegistryText(text: LibUtilityParseWindowsRegistryTextText): LibUtilityParseWindowsRegistryTextReturns;
+export declare function pathExists(path: LibUtilityPathExistsPath): LibUtilityPathExistsReturns;
+export declare function renameFileWithDate(oldPath: LibUtilityRenameFileWithDateOldPath): LibUtilityRenameFileWithDateReturns;
+export declare function resolveTemplatePath(importMetaUrl: LibUtilityResolveTemplatePathImportMetaUrl, subpath: LibUtilityResolveTemplatePathSubpath): LibUtilityResolveTemplatePathReturns;
+export declare function saveGeneratedFile(targetPath: LibUtilitySaveGeneratedFileTargetPath, contents: LibUtilitySaveGeneratedFileContents, replaceFile: LibUtilitySaveGeneratedFileReplaceFile): LibUtilitySaveGeneratedFileReturns;
+export declare function saveWorkspaceManifest(workspace: LibUtilitySaveWorkspaceManifestWorkspace, replaceFile: LibUtilitySaveWorkspaceManifestReplaceFile): LibUtilitySaveWorkspaceManifestReturns;
 //# sourceMappingURL=utility.d.ts.map

package/build/src/lib/utility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../../../src/lib/utility.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAIV,uBAAuB,EACvB,kBAAkB,EAClB,8BAA8B,EAE9B,6BAA6B,EAG7B,4BAA4B,EAG5B,mBAAmB,EAKnB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EAExB,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,EAClB,6BAA6B,EAC7B,oBAAoB,EACpB,6BAA6B,EAG7B,6BAA6B,EAC7B,8BAA8B,EAE9B,8BAA8B,EAC9B,2BAA2B,EAC3B,sCAAsC,EACtC,gCAAgC,EAGhC,+BAA+B,EAC/B,4BAA4B,EAC5B,cAAc,EACd,iBAAiB,EACjB,yBAAyB,EACzB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,gCAAgC,EAChC,4BAA4B,EAC5B,8BAA8B,EAC/B,MAAM,0BAA0B,CAAC;AASlC,wBAAgB,gBAAgB,IAAI,uBAAuB,CAoC1D;AASD,wBAAgB,WAAW,IAAI,kBAAkB,CAwBhD;AAYD,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,6BAA6B,EAAE,SAAS,EAAE,8BAA8B,GAAG,4BAA4B,CA+G5J;AAWD,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CA+HpF;AAWD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,sBAAsB,CAoB7F;AAWD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,KAAK,IAAI,4BAA4B,CAe1G;AAYD,wBAAsB,eAAe,CAAC,gBAAgB,EAAE,+BAA+B,EAAE,gBAAgB,EAAE,+BAA+B,GAAG,sBAAsB,CAqDlK;AAWD,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,KAAK,IAAI,sBAAsB,CAaxF;AAWD,wBAAsB,aAAa,CAAC,gBAAgB,EAAE,6BAA6B,GAAG,oBAAoB,CAgDzG;AAWD,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,6BAA6B,GAAG,6BAA6B,CAuClH;AASD,wBAAsB,uBAAuB,IAAI,8BAA8B,CAI9E;AAWD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,2BAA2B,GAAG,8BAA8B,CA4BzG;AAWD,wBAAsB,yBAAyB,CAAC,aAAa,EAAE,sCAAsC,GAAG,gCAAgC,CAevI;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,4BAA4B,GAAG,+BAA+B,CA0B5G;AAWD,wBAAsB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,iBAAiB,CAQxE;AAaD,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,EAAE,wBAAwB,GAAG,yBAAyB,CAgD1K;AAYD,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,8BAA8B,EAAE,WAAW,EAAE,gCAAgC,GAAG,4BAA4B,CAmBlK"}
+{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../../../src/lib/utility.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAiBV,iCAAiC,EAUjC,4BAA4B,EAE5B,wCAAwC,EAExC,uCAAuC,EAMvC,sCAAsC,EAMtC,6BAA6B,EAe7B,6BAA6B,EAO7B,gCAAgC,EAGhC,gCAAgC,EAChC,kCAAkC,EAQlC,sCAAsC,EAEtC,yCAAyC,EAIzC,yCAAyC,EACzC,gCAAgC,EAEhC,+BAA+B,EAC/B,kCAAkC,EAGlC,8BAA8B,EAI9B,gCAAgC,EAChC,4BAA4B,EAC5B,uCAAuC,EAKvC,8BAA8B,EAI9B,uCAAuC,EAMvC,uCAAuC,EAGvC,wCAAwC,EAMxC,wCAAwC,EACxC,qCAAqC,EAIrC,gDAAgD,EAChD,0CAA0C,EAO1C,yCAAyC,EACzC,sCAAsC,EACtC,wBAAwB,EACxB,2BAA2B,EAO3B,mCAAmC,EAGnC,mCAAmC,EAKnC,0CAA0C,EAC1C,oCAAoC,EACpC,oCAAoC,EACpC,mCAAmC,EAInC,sCAAsC,EACtC,kCAAkC,EAClC,qCAAqC,EACrC,0CAA0C,EAC1C,sCAAsC,EACtC,wCAAwC,EACzC,MAAM,2BAA2B,CAAC;AAYnC,wBAAgB,gBAAgB,IAAI,iCAAiC,CA6CpE;AAYD,wBAAgB,WAAW,IAAI,4BAA4B,CA2B1D;AAeD,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,uCAAuC,EAAE,SAAS,EAAE,wCAAwC,GAAG,sCAAsC,CAkH1L;AAcD,wBAAsB,YAAY,CAAC,OAAO,EAAE,6BAA6B,GAAG,6BAA6B,CA+JxG;AAcD,wBAAsB,eAAe,CAAC,OAAO,EAAE,gCAAgC,GAAG,gCAAgC,CA4BjH;AAcD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kCAAkC,GAAG,KAAK,IAAI,sCAAsC,CAsB9H;AAeD,wBAAsB,eAAe,CAAC,gBAAgB,EAAE,yCAAyC,EAAE,gBAAgB,EAAE,yCAAyC,GAAG,gCAAgC,CAqDhM;AAeD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,+BAA+B,EAAE,WAAW,EAAE,kCAAkC,GAAG,8BAA8B,CA2BxJ;AAcD,wBAAgB,aAAa,CAAC,KAAK,EAAE,4BAA4B,GAAG,KAAK,IAAI,gCAAgC,CAa5G;AAcD,wBAAsB,aAAa,CAAC,gBAAgB,EAAE,uCAAuC,GAAG,8BAA8B,CAsD7H;AAcD,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,uCAAuC,GAAG,uCAAuC,CAyCtI;AAYD,wBAAsB,uBAAuB,IAAI,wCAAwC,CAExF;AAcD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qCAAqC,GAAG,wCAAwC,CA4B7H;AAcD,wBAAsB,yBAAyB,CAAC,aAAa,EAAE,gDAAgD,GAAG,0CAA0C,CAc3J;AAcD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,sCAAsC,GAAG,yCAAyC,CA0BhI;AAcD,wBAAsB,UAAU,CAAC,IAAI,EAAE,wBAAwB,GAAG,2BAA2B,CAQ5F;AAcD,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,mCAAmC,GAAG,mCAAmC,CAmD1H;AAeD,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,0CAA0C,EAAE,OAAO,EAAE,oCAAoC,GAAG,oCAAoC,CAKlL;AAgBD,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,qCAAqC,EAAE,QAAQ,EAAE,mCAAmC,EAAE,WAAW,EAAE,sCAAsC,GAAG,kCAAkC,CAiCjO;AAeD,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,wCAAwC,EAAE,WAAW,EAAE,0CAA0C,GAAG,sCAAsC,CAkBhM"}

package/build/src/lib/utility.js

@@ -1,11 +1,13 @@
 import { exec, spawn } from 'child_process';
 import { promises as fs } from 'fs';
 import { platform } from 'os';
-import { dirname, join, parse, resolve, } from 'path';
+import { dirname, join, parse, relative, resolve, } from 'path';
+import { fileURLToPath } from 'url';
 import { promisify } from 'util';
-import { itemSkipDirectories } from './item.js';
-import { CHARACTER_DOUBLE_QUOTE, CHARACTER_SINGLE_QUOTE, LINEBREAK_CRLF_OR_LF, PATTERN_DOUBLE_QUOTED_STRING_CAPTURE, PATTERN_REGISTRY_QUERY_LINE, } from './regex.js';
+import chalk from 'chalk';
 import { Logger } from '../toolkit/index.js';
+import { libItemSkipDirectories } from './item.js';
+import { LIB_REGEX_CHARACTER_DOUBLE_QUOTE, LIB_REGEX_CHARACTER_SINGLE_QUOTE, LIB_REGEX_LINEBREAK_CRLF_OR_LF, LIB_REGEX_PATTERN_DOUBLE_QUOTED_STRING_CAPTURE, LIB_REGEX_PATTERN_LEADING_DOT, LIB_REGEX_PATTERN_REGISTRY_QUERY_LINE, } from './regex.js';
 export function currentTimestamp() {
     const now = new Date();
     const padLeft = (number, width = 2) => {
@@ -13,16 +15,22 @@ export function currentTimestamp() {
         return number.toString().padStart(currentWidth, '0');
     };
     const year = now.getFullYear();
-    const month = padLeft(now.getMonth() + 1);
-    const day = padLeft(now.getDate());
-    const hour = padLeft(now.getHours());
-    const minute = padLeft(now.getMinutes());
-    const second = padLeft(now.getSeconds());
+    const rawMonth = now.getMonth() + 1;
+    const month = padLeft(rawMonth);
+    const rawDate = now.getDate();
+    const day = padLeft(rawDate);
+    const rawHours = now.getHours();
+    const hour = padLeft(rawHours);
+    const rawMinutes = now.getMinutes();
+    const minute = padLeft(rawMinutes);
+    const rawSeconds = now.getSeconds();
+    const second = padLeft(rawSeconds);
     const millisecond = now.getMilliseconds().toString().padStart(3, '0');
     const timezoneOffsetMinutes = -now.getTimezoneOffset();
     const timezoneSign = (timezoneOffsetMinutes >= 0) ? '+' : '-';
     const timezoneAbs = Math.abs(timezoneOffsetMinutes);
-    const timezoneHours = padLeft(Math.trunc(timezoneAbs / 60));
+    const timezoneHoursTruncated = Math.trunc(timezoneAbs / 60);
+    const timezoneHours = padLeft(timezoneHoursTruncated);
     const timezoneMinutes = padLeft(timezoneAbs % 60);
     return `[${year}-${month}-${day} ${hour}:${minute}:${second}.${millisecond} ${timezoneSign}${timezoneHours}${timezoneMinutes}]`;
 }
@@ -37,7 +45,10 @@ export function detectShell() {
     if (currentPlatform === 'linux') {
         return '/bin/bash';
     }
-    if (['aix', 'sunos'].includes(currentPlatform)) {
+    if ([
+        'aix',
+        'sunos',
+    ].includes(currentPlatform) === true) {
         return '/bin/ksh';
     }
     return '/bin/sh';
@@ -69,7 +80,7 @@ export async function discoverPathsWithFile(fileName, direction) {
     if (direction === 'forward') {
         const queue = [startDirectory];
         const visited = new Set();
-        const skipDirectories = new Set(itemSkipDirectories);
+        const skipDirectories = new Set(libItemSkipDirectories);
         while (queue.length > 0) {
             const currentDirectory = queue.shift();
             if (currentDirectory === undefined) {
@@ -79,38 +90,40 @@ export async function discoverPathsWithFile(fileName, direction) {
                 name: 'discoverPathsWithFile',
                 purpose: 'forward',
             }).debug(`Current directory: "${currentDirectory}"`);
-            let realDirectory;
+            let realDirectory = undefined;
             try {
                 realDirectory = await fs.realpath(currentDirectory);
             }
             catch {
                 continue;
             }
-            if (visited.has(realDirectory)) {
+            if (visited.has(realDirectory) === true) {
                 continue;
             }
             visited.add(realDirectory);
-            let entries;
+            let entries = undefined;
             try {
                 entries = await fs.readdir(realDirectory, { withFileTypes: true });
             }
             catch {
                 continue;
             }
+            if (entries.some((entry) => entry.isFile() === true && entry.name === '.novaignore') === true) {
+                continue;
+            }
             let hasTargetFile = false;
             for (const entry of entries) {
-                if (entry.isFile() && entry.name === fileName) {
+                if (entry.isFile() === true && entry.name === fileName) {
                     hasTargetFile = true;
                     continue;
                 }
-                if (!entry.isDirectory()) {
+                if (entry.isDirectory() === false) {
                     continue;
                 }
-                if (entry.name.startsWith('.') || skipDirectories.has(entry.name)) {
+                if (entry.name.startsWith('.') === true || skipDirectories.has(entry.name) === true) {
                     continue;
                 }
-                const nextDirectory = join(realDirectory, entry.name);
-                queue.push(nextDirectory);
+                queue.push(join(realDirectory, entry.name));
             }
             if (hasTargetFile === true) {
                 results.push(realDirectory);
@@ -122,36 +135,51 @@ export async function discoverPathsWithFile(fileName, direction) {
 export async function executeShell(command) {
     const execAsync = promisify(exec);
     const shell = detectShell();
+    const commandName = command.split(' ')[0] ?? '';
+    const commandOnPath = await isCommandExists(commandName);
     let fullCommand = command;
-    const quotePosix = (string) => string.replace(new RegExp(CHARACTER_SINGLE_QUOTE.source, 'g'), '\'\\\'\'');
-    const quoteWindows = (string) => string.replace(new RegExp(CHARACTER_DOUBLE_QUOTE.source, 'g'), '"');
+    const quotePosix = (string) => {
+        const pattern = new RegExp(LIB_REGEX_CHARACTER_SINGLE_QUOTE.source, 'g');
+        return string.replace(pattern, '\'\\\'\'');
+    };
+    const quoteWindows = (string) => {
+        const pattern = new RegExp(LIB_REGEX_CHARACTER_DOUBLE_QUOTE.source, 'g');
+        return string.replace(pattern, '"');
+    };
     if (shell === 'cmd.exe') {
         fullCommand = `cmd.exe /d /s /c "${quoteWindows(fullCommand)}"`;
     }
-    if (shell === '/bin/zsh') {
+    if (shell === '/bin/zsh' && commandOnPath === true) {
+        fullCommand = `/bin/zsh -c '${quotePosix(fullCommand)}'`;
+    }
+    if (shell === '/bin/zsh' && commandOnPath === false) {
         fullCommand = `/bin/zsh -l -i -c '${quotePosix(fullCommand)}'`;
     }
-    if (shell === '/bin/bash') {
+    if (shell === '/bin/bash' && commandOnPath === true) {
+        fullCommand = `setsid -w /bin/bash -c '${quotePosix(fullCommand)}' </dev/null`;
+    }
+    if (shell === '/bin/bash' && commandOnPath === false) {
         fullCommand = `setsid -w /bin/bash -l -i -c '${quotePosix(fullCommand)}' </dev/null`;
     }
     if (shell === '/bin/sh') {
         fullCommand = `/bin/sh -c '${quotePosix(fullCommand)}'`;
     }
     try {
-        const { stdout, stderr } = await execAsync(fullCommand, {
+        const execResult = await execAsync(fullCommand, {
             encoding: 'utf-8',
             windowsHide: true,
             timeout: 15000,
             env: {
                 ...process.env,
-                ...(await isCommandExists('corepack')) ? {
+                SHELL_SESSIONS_DISABLE: '1',
+                ...(await isCommandExists('corepack') === true) ? {
                     COREPACK_ENABLE_STRICT: '0',
                 } : {},
                 ...(process.env['_VOLTA_TOOL_RECURSION'] !== undefined) ? {
                     PATH: [
-                        ...(process.env['ProgramW6432']) ? [`${process.env['ProgramW6432']}\\Volta\\`] : [],
-                        ...(process.env['LOCALAPPDATA']) ? [`${process.env['LOCALAPPDATA']}\\Volta\\bin`] : [],
-                        ...(process.env['PATH']) ? [process.env['PATH']] : [],
+                        ...(process.env['ProgramW6432'] !== undefined) ? [`${process.env['ProgramW6432']}\\Volta\\`] : [],
+                        ...(process.env['LOCALAPPDATA'] !== undefined) ? [`${process.env['LOCALAPPDATA']}\\Volta\\bin`] : [],
+                        ...(process.env['PATH'] !== undefined) ? [process.env['PATH']] : [],
                     ].join(';'),
                 } : {},
                 ...(shell === '/bin/bash') ? {
@@ -161,6 +189,8 @@ export async function executeShell(command) {
             cwd: process.cwd(),
             maxBuffer: 8 * 1024 * 1024,
         });
+        const stdout = execResult['stdout'];
+        const stderr = execResult['stderr'];
         const output = {
             textOut: stdout.trim(),
             textError: stderr.trim(),
@@ -182,7 +212,7 @@ export async function executeShell(command) {
             textError: '',
             code: 1,
         };
-        if (isExecuteShellError(error)) {
+        if (isExecuteShellError(error) === true) {
             if (error.stdout !== undefined) {
                 output.textOut = `${error.stdout}`;
             }
@@ -206,18 +236,25 @@ export async function executeShell(command) {
 }
 export async function isCommandExists(command) {
     const isWin = platform() === 'win32';
-    const bin = (isWin) ? 'where' : 'sh';
-    const args = (isWin) ? ['/Q', command] : ['-c', `command -v "${command}" >/dev/null 2>&1`];
-    return new Promise((resolve) => {
-        const childProcess = spawn(bin, args, {
+    const bin = (isWin === true) ? 'where' : 'sh';
+    const commandArguments = (isWin === true) ? [
+        '/Q',
+        command,
+    ] : [
+        '-c',
+        `command -v "${command}" >/dev/null 2>&1`,
+    ];
+    return new Promise((promiseResolve) => {
+        const childProcess = spawn(bin, commandArguments, {
             stdio: 'ignore',
         });
         childProcess.once('error', () => {
-            return resolve(false);
+            return promiseResolve(false);
         });
         childProcess.once('exit', (code) => {
-            return resolve(code === 0);
+            return promiseResolve(code === 0);
         });
+        return;
     });
 }
 export function isExecuteShellError(error) {
@@ -225,22 +262,27 @@ export function isExecuteShellError(error) {
         return false;
     }
     const object = error;
-    const hasCmd = 'cmd' in object && typeof object['cmd'] === 'string';
+    const hasCommand = 'cmd' in object && typeof object['cmd'] === 'string';
     const hasKilled = 'killed' in object && typeof object['killed'] === 'boolean';
     const hasCode = 'code' in object && typeof object['code'] === 'number';
     const hasSignal = 'signal' in object && typeof object['signal'] === 'string';
     const hasStdout = 'stdout' in object && typeof object['stdout'] === 'string';
     const hasStderr = 'stderr' in object && typeof object['stderr'] === 'string';
-    return hasCmd || hasKilled || hasCode || hasSignal || hasStdout || hasStderr;
+    return (hasCommand === true
+        || hasKilled === true
+        || hasCode === true
+        || hasSignal === true
+        || hasStdout === true
+        || hasStderr === true);
 }
 export async function isFileIdentical(existingFilePath, proposedContents) {
-    let oldFileContents;
-    let newFileContents;
+    let oldFileContents = undefined;
+    let newFileContents = undefined;
     if (typeof proposedContents === 'string') {
         newFileContents = proposedContents;
     }
     else {
-        let serialized;
+        let serialized = undefined;
         try {
             serialized = JSON.stringify(proposedContents, null, 2);
         }
@@ -271,18 +313,37 @@ export async function isFileIdentical(existingFilePath, proposedContents) {
         return false;
     }
     const isIdentical = oldFileContents === newFileContents;
-    const comparisonResult = (isIdentical) ? 'matches' : 'differs from';
+    const comparisonResult = (isIdentical === true) ? 'matches' : 'differs from';
     Logger.customize({
         name: 'isFileIdentical',
-        purpose: (isIdentical) ? 'identical' : 'different',
+        purpose: (isIdentical === true) ? 'identical' : 'different',
     }).debug(`Existing file "${existingFilePath}" ${comparisonResult} proposed contents.`);
     return isIdentical;
 }
+export function isIgnoredFile(filename, ignoreFiles) {
+    const normalizedFilename = filename.replaceAll('\\', '/');
+    for (const pattern of ignoreFiles) {
+        const strippedPattern = (pattern.startsWith('./') === true) ? pattern.slice(2) : pattern;
+        const normalizedPattern = strippedPattern.replaceAll('\\', '/');
+        if (normalizedPattern.startsWith('*') === true) {
+            const suffix = normalizedPattern.slice(1);
+            if (normalizedFilename.endsWith(suffix) === true) {
+                return true;
+            }
+            continue;
+        }
+        if (normalizedFilename === normalizedPattern
+            || normalizedFilename.endsWith(`/${normalizedPattern}`) === true) {
+            return true;
+        }
+    }
+    return false;
+}
 export function isPlainObject(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
     }
-    if (Array.isArray(value)) {
+    if (Array.isArray(value) === true) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);
@@ -295,40 +356,43 @@ export async function isProjectRoot(currentDirectory) {
         purpose: 'detectedLocations',
     }).debug(locations);
     if (locations.length < 1) {
+        const lessThanOneMessage = [
+            'No "package.json" files were found. Re-run this command inside the project root directory.',
+            `Current directory is "${currentDirectory}"`,
+        ].join('\n');
         Logger.customize({
             name: 'isProjectRoot',
             purpose: 'lessThanOne',
-        }).error([
-            'No "package.json" files were found. Re-run this command inside the project root directory.',
-            `Current directory is "${currentDirectory}"`,
-        ].join('\n'));
+        }).error(lessThanOneMessage);
         return false;
     }
     if (locations.length > 1) {
+        const greaterThanOneMessage = [
+            'Multiple "package.json" files were found. Re-run this command inside the project root directory.',
+            `Current directory is "${currentDirectory}"`,
+        ].join('\n');
         Logger.customize({
             name: 'isProjectRoot',
             purpose: 'greaterThanOne',
-        }).error([
-            'Multiple "package.json" files were found. Re-run this command inside the project root directory.',
-            `Current directory is "${currentDirectory}"`,
-        ].join('\n'));
+        }).error(greaterThanOneMessage);
         return false;
     }
     if (locations.length === 1 && locations[0] !== currentDirectory) {
-        Logger.customize({
-            name: 'isProjectRoot',
-            purpose: 'notProjectRootDir',
-        }).error([
+        const notProjectRootDirectoryMessage = [
             'Must be run inside the project root directory.',
             `Current directory is "${currentDirectory}"`,
-        ].join('\n'));
+        ].join('\n');
+        Logger.customize({
+            name: 'isProjectRoot',
+            purpose: 'notProjectRootDirectory',
+        }).error(notProjectRootDirectoryMessage);
         return false;
     }
     return true;
 }
 export async function loadWorkspaceManifests(options) {
-    const projectRoot = options.projectRoot;
-    const workspaces = options.workspaces;
+    const projectRoot = options['projectRoot'];
+    const workspaces = options['workspaces'];
     const packageJsons = [];
     for (const workspace of workspaces) {
         const relativeWorkspacePath = workspace[0];
@@ -349,26 +413,26 @@ export async function loadWorkspaceManifests(options) {
             }).debug(`Loaded package manifest for workspace "${relativeWorkspacePath}".`);
         }
         catch (error) {
+            const loadErrorMessage = [
+                `Skipping workspace "${relativeWorkspacePath}" because the "package.json" file is inaccessible or invalid.`,
+                error,
+            ].join('\n');
             Logger.customize({
                 name: 'loadWorkspaceManifests',
                 purpose: 'load',
-            }).error([
-                `Skipping workspace "${relativeWorkspacePath}" because the "package.json" file is inaccessible or invalid.`,
-                error,
-            ].join('\n'));
+            }).error(loadErrorMessage);
         }
     }
     return packageJsons;
 }
 export async function parseLinuxOsReleaseFile() {
-    const query = await executeShell('cat /etc/os-release');
-    return parseLinuxOsReleaseText(query.textOut);
+    return parseLinuxOsReleaseText((await executeShell('cat /etc/os-release'))['textOut']);
 }
 export function parseLinuxOsReleaseText(text) {
-    const lines = text.split(LINEBREAK_CRLF_OR_LF);
+    const lines = text.split(LIB_REGEX_LINEBREAK_CRLF_OR_LF);
     const osReleaseEntries = {};
     for (const line of lines) {
-        if (line === '' || line.startsWith('#')) {
+        if (line === '' || line.startsWith('#') === true) {
             continue;
         }
         const parts = line.split('=');
@@ -378,16 +442,15 @@ export function parseLinuxOsReleaseText(text) {
             continue;
         }
         let value = rest.join('=');
-        value = value.replace(PATTERN_DOUBLE_QUOTED_STRING_CAPTURE, '$1');
+        value = value.replace(LIB_REGEX_PATTERN_DOUBLE_QUOTED_STRING_CAPTURE, '$1');
         Reflect.set(osReleaseEntries, key, value);
     }
     return osReleaseEntries;
 }
 export async function parseWindowsRegistryQuery(registryPaths) {
-    const paths = Array.isArray(registryPaths) ? registryPaths : [registryPaths];
+    const paths = (Array.isArray(registryPaths) === true) ? registryPaths : [registryPaths];
     for (const path of paths) {
-        const query = await executeShell(`reg query "${path}"`);
-        const registryKeys = parseWindowsRegistryText(query.textOut);
+        const registryKeys = parseWindowsRegistryText((await executeShell(`reg query "${path}"`))['textOut']);
         if (Object.keys(registryKeys).length > 0) {
             return registryKeys;
         }
@@ -395,10 +458,10 @@ export async function parseWindowsRegistryQuery(registryPaths) {
     return {};
 }
 export function parseWindowsRegistryText(text) {
-    const lines = text.split(LINEBREAK_CRLF_OR_LF);
+    const lines = text.split(LIB_REGEX_LINEBREAK_CRLF_OR_LF);
     const registryKeys = {};
     for (const line of lines) {
-        const matches = line.match(PATTERN_REGISTRY_QUERY_LINE);
+        const matches = line.match(LIB_REGEX_PATTERN_REGISTRY_QUERY_LINE);
         if (matches !== null) {
             const registryKey = matches[1];
             const registryKeyType = matches[2];
@@ -424,8 +487,11 @@ export async function pathExists(path) {
         return false;
     }
 }
-export async function renameFileWithDate(oldPath, prefix, suffix) {
+export async function renameFileWithDate(oldPath) {
     const directory = dirname(oldPath);
+    const parsed = parse(oldPath);
+    const prefix = (parsed.base.startsWith('.') === true) ? parsed.base : parsed.name;
+    const suffix = (parsed.base.startsWith('.') === true) ? '' : parsed.ext.replace(LIB_REGEX_PATTERN_LEADING_DOT, '');
     const now = new Date();
     const timestamp = [
         now.getUTCFullYear(),
@@ -435,7 +501,7 @@ export async function renameFileWithDate(oldPath, prefix, suffix) {
     let counter = 1;
     while (true) {
         const counterLabel = counter.toString().padStart(4, '0');
-        const newFileName = `${prefix}.${timestamp}_${counterLabel}.${suffix}`;
+        const newFileName = (suffix !== '') ? `${prefix}.${timestamp}_${counterLabel}.nova-backup.${suffix}` : `${prefix}.${timestamp}_${counterLabel}.nova-backup`;
         const newPath = join(directory, newFileName);
         try {
             await fs.access(newPath);
@@ -464,15 +530,43 @@ export async function renameFileWithDate(oldPath, prefix, suffix) {
         }
     }
 }
+export function resolveTemplatePath(importMetaUrl, subpath) {
+    const filePath = fileURLToPath(importMetaUrl);
+    const currentDirectory = dirname(filePath);
+    return join(currentDirectory, '..', '..', '..', '..', 'templates', subpath);
+}
+export async function saveGeneratedFile(targetPath, contents, replaceFile) {
+    const parentDirectory = dirname(targetPath);
+    const currentDirectory = process.cwd();
+    const displayName = relative(currentDirectory, targetPath);
+    await fs.mkdir(parentDirectory, { recursive: true });
+    if (await pathExists(targetPath) === true) {
+        if (await isFileIdentical(targetPath, contents) === true) {
+            Logger.customize({
+                name: 'saveGeneratedFile',
+                purpose: 'identical',
+            }).info(`Skipping ${chalk.cyan(`"${displayName}"`)} (identical content).`);
+            return;
+        }
+        if (replaceFile === false) {
+            await renameFileWithDate(targetPath);
+        }
+    }
+    await fs.writeFile(targetPath, contents, 'utf-8');
+    Logger.customize({
+        name: 'saveGeneratedFile',
+        purpose: 'generated',
+    }).info(`Generated ${chalk.cyan(`"${displayName}"`)}.`);
+    return;
+}
 export async function saveWorkspaceManifest(workspace, replaceFile) {
-    if (await isFileIdentical(workspace.filePath, workspace.fileContents)) {
+    if (await isFileIdentical(workspace['filePath'], workspace['fileContents']) === true) {
         return;
     }
     if (replaceFile === false) {
-        await renameFileWithDate(workspace.filePath, 'package', 'json');
+        await renameFileWithDate(workspace['filePath']);
     }
-    const packageJson = JSON.stringify(workspace.fileContents, null, 2);
-    const packageContents = `${packageJson}\n`;
-    await fs.writeFile(workspace.filePath, packageContents, 'utf-8');
+    await fs.writeFile(workspace['filePath'], `${JSON.stringify(workspace['fileContents'], null, 2)}\n`, 'utf-8');
+    return;
 }
 //# sourceMappingURL=utility.js.map