@appweaver/cli 1.0.0

package/update/update-command.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCommand = updateCommand;
+const common_1 = require("@appweaver/common");
+const utils_1 = require("../utils");
+const update_packages_1 = require("./update-packages");
+const update_skill_1 = require("./update-skill");
+function updateCommand(program) {
+    program
+        .command('update')
+        .alias('u')
+        .description('Update the Appweaver packages.')
+        .argument('[packages...]', 'A list of packages to update (e.g. @appweaver/core @appweaver/cli).' +
+        'Defaults to all currently installed @appweaver/* packages.')
+        .option('--targetVersion [targetVersion]', 'The version to update the packages.', 'latest')
+        .option('--noSkill', 'Skip updating AI agents skill files in the current project.')
+        .option('-f, --force', 'Force update despite peerDependency version mismatches.')
+        .option('--verbose', 'Print verbose output.')
+        .action(async (packages, _, command) => {
+        const quiet = !command.getOptionValue('verbose');
+        const force = command.getOptionValue('force');
+        const updateSkill = !command.getOptionValue('noSkill');
+        const targetVersion = command.getOptionValue('targetVersion');
+        // Load all currently installed packages
+        const installedPackages = {};
+        try {
+            const pkg = await (0, utils_1.loadLocalPackageJson)();
+            const allDeps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.devDependencies ?? {})
+            };
+            for (const [name, version] of Object.entries(allDeps)) {
+                installedPackages[name] = version;
+            }
+        }
+        catch (e) {
+            if (!quiet) {
+                console.error(e);
+            }
+            console.error('Unable to open package.json file');
+            process.exit(1);
+        }
+        // Create a list of packages to update (without version suffix)
+        const packagesToUpdate = [];
+        if (packages.length > 0) {
+            packagesToUpdate.push(...packages.map((p) => {
+                const at = p.lastIndexOf('@');
+                return at > 0 ? p.slice(0, at) : p;
+            }));
+        }
+        else {
+            packagesToUpdate.push(...Object.keys(installedPackages));
+        }
+        // This command should only update Appweaver packages
+        const appweaverPackages = packagesToUpdate.filter((p) => p.startsWith('@appweaver/'));
+        if (appweaverPackages.length === 0) {
+            console.log(`No @appweaver packages found for update.`);
+            process.exit(0);
+        }
+        // Check if there are already greater versions installed for each package
+        if (targetVersion !== 'latest' && !quiet) {
+            for (const packageName of packagesToUpdate) {
+                const installedPackageVersion = installedPackages[packageName];
+                if (installedPackageVersion) {
+                    const cleanInstalled = installedPackageVersion.replace(/^[^0-9]*/, '');
+                    if ((0, common_1.compareVersions)(cleanInstalled, targetVersion) > 0) {
+                        console.warn(`${packageName} already has greater version ${cleanInstalled} than the requested version ${targetVersion}`);
+                    }
+                }
+            }
+        }
+        const status = await (0, update_packages_1.updatePackages)(appweaverPackages, targetVersion, force, quiet);
+        if (status === 0) {
+            if (updateSkill) {
+                await (0, update_skill_1.updateSkillFiles)(quiet);
+            }
+            console.log(`Successfully updated packages to ${targetVersion} version.`);
+        }
+        else {
+            console.error('Update did not complete successfully. Use --verbose flag to see error details.');
+            process.exit(1);
+        }
+    });
+}

package/update/update-packages.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Updates a list of packages to the specified version.
+ *
+ * @param {string[]} packages - An array of package names to be updated.
+ * @param {string} version - The version to which the packages should be updated.
+ * @param {boolean} [force=false] - Whether to forcibly update the packages, overriding any potential constraints.
+ * @param {boolean} [quiet=true] - Whether to suppress output logs during the update process.
+ * @return {Promise<number>} Resolves to the number of packages successfully updated.
+ */
+export declare function updatePackages(packages: string[], version: string, force?: boolean, quiet?: boolean): Promise<number>;

package/update/update-packages.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackages = updatePackages;
+const common_1 = require("@appweaver/common");
+const utils_1 = require("../utils");
+/**
+ * Updates a list of packages to the specified version.
+ *
+ * @param {string[]} packages - An array of package names to be updated.
+ * @param {string} version - The version to which the packages should be updated.
+ * @param {boolean} [force=false] - Whether to forcibly update the packages, overriding any potential constraints.
+ * @param {boolean} [quiet=true] - Whether to suppress output logs during the update process.
+ * @return {Promise<number>} Resolves to the number of packages successfully updated.
+ */
+async function updatePackages(packages, version, force = false, quiet = true) {
+    const packagesWithVersion = packages.map((p) => `${p}@${version}`);
+    if ((0, utils_1.isBunProcess)() && common_1.config.APP_RUNTIME === common_1.Runtime.Bun) {
+        return updateBunPackages(packagesWithVersion, quiet);
+    }
+    else {
+        return updateNodePackages(packagesWithVersion, force, quiet);
+    }
+}
+/**
+ * Updates the specified Node.js packages using npm.
+ *
+ * @param {string[]} packages - An array of package names to update.
+ * @param {boolean} force - A flag indicating whether to force the update by ignoring peer dependencies.
+ * @param {boolean} quiet - A flag indicating whether to suppress output during the update process.
+ * @return {Promise<number>} A promise that resolves with the exit code of the npm process.
+ */
+async function updateNodePackages(packages, force, quiet) {
+    return (0, utils_1.runProcess)('npm', ['install', ...packages, ...(force ? ['--legacy-peer-deps'] : [])], { quiet });
+}
+/**
+ * Updates the specified Bun packages by adding them to the project.
+ *
+ * @param {string[]} packages - An array of package names to update or add.
+ * @param {boolean} quiet - A flag to suppress output if set to true.
+ * @return {Promise<number>} A promise that resolves to the exit code of the process.
+ */
+async function updateBunPackages(packages, quiet) {
+    // Bun already handles peerDependency version mismatch without error
+    return (0, utils_1.runProcess)('bun', ['add', ...packages], { quiet });
+}

package/update/update-skill.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Updates skill files and AI guidelines in the project by copying the skill directory
+ * to specified agent directories and updating references in guideline files.
+ *
+ * @param {boolean} quiet - If true, suppresses logging output; otherwise, logs actions performed.
+ * @return {Promise<void>} A promise that resolves when the update process is complete.
+ */
+export declare function updateSkillFiles(quiet: boolean): Promise<void>;

package/update/update-skill.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSkillFiles = updateSkillFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Updates skill files and AI guidelines in the project by copying the skill directory
+ * to specified agent directories and updating references in guideline files.
+ *
+ * @param {boolean} quiet - If true, suppresses logging output; otherwise, logs actions performed.
+ * @return {Promise<void>} A promise that resolves when the update process is complete.
+ */
+async function updateSkillFiles(quiet) {
+    const projectDir = process.cwd();
+    const skillDir = node_path_1.default.join(__dirname, '..', 'skill');
+    if (!(await exists(skillDir))) {
+        if (!quiet) {
+            console.warn('Skill directory not found, skipping skill file update.\n');
+        }
+        return;
+    }
+    const guidelinesFilePath = node_path_1.default.join(skillDir, 'GUIDELINES.md');
+    const guidelinesContents = await promises_1.default.readFile(guidelinesFilePath, 'utf8');
+    const foundAgentDirs = [];
+    for (const agentDir of [
+        '.claude',
+        '.junie',
+        '.kiro',
+        '.pi',
+        '.github',
+        '.opencode',
+        '.agents'
+    ]) {
+        const agentDirPath = node_path_1.default.join(projectDir, agentDir);
+        if (!(await exists(agentDirPath))) {
+            continue;
+        }
+        foundAgentDirs.push(agentDir);
+        // Copy skill directory to {agentDir}/skills/appweaver/
+        const skillDestPath = node_path_1.default.join(agentDirPath, 'skills', 'appweaver');
+        await promises_1.default.cp(skillDir, skillDestPath, {
+            recursive: true,
+            filter: (src) => !src.endsWith('GUIDELINES.md')
+        });
+        if (!quiet) {
+            console.log(`Updated skill files in ${node_path_1.default.join(agentDir, 'skills', 'appweaver')}\n`);
+        }
+    }
+    let firstAgentDir = foundAgentDirs[0];
+    for (const guidelinesFile of ['AGENTS.md', 'CLAUDE.md']) {
+        const guidelinesFilePath = node_path_1.default.join(projectDir, guidelinesFile);
+        // Update only agent guidelines files that already exist
+        if (!(await exists(guidelinesFilePath))) {
+            continue;
+        }
+        // If no agent-specific dir was discovered, create new generic .agents dir
+        if (!firstAgentDir) {
+            firstAgentDir = '.agents';
+            const skillDestPath = node_path_1.default.join(node_path_1.default.join(projectDir, firstAgentDir), 'skills', 'appweaver');
+            await promises_1.default.cp(skillDir, skillDestPath, {
+                recursive: true,
+                filter: (src) => !src.endsWith('GUIDELINES.md')
+            });
+        }
+        // Replace guideline file path references with path references in first
+        // discovered agents dir
+        const referencesPath = node_path_1.default
+            .join(firstAgentDir, 'skills', 'appweaver', 'references')
+            .replace(/\\/g, '/');
+        const guidelinesContent = guidelinesContents.replace(/(\[.+]\()references\/(.+\))/g, `$1${referencesPath}/$2`);
+        await promises_1.default.writeFile(guidelinesFilePath, guidelinesContent, {
+            encoding: 'utf8'
+        });
+        if (!quiet) {
+            console.log(`Updated AI guidelines file ${guidelinesFile}\n`);
+        }
+        // Update only the first found guidelines file
+        break;
+    }
+}
+async function exists(filePath) {
+    try {
+        await promises_1.default.access(filePath, node_fs_1.default.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './loader-util';
+export * from './path-util';
+export * from './process-util';

package/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./loader-util"), exports);
+__exportStar(require("./path-util"), exports);
+__exportStar(require("./process-util"), exports);

package/utils/loader-util.d.ts

@@ -0,0 +1,29 @@
+import { ResourceModel } from '@appweaver/common';
+/**
+ * Loads and parses the `package.json` file located in the CLI project package directory.
+ * The function attempts to locate the `package.json` file in one of two
+ * predefined directories relative to the current module's directory.
+ * If the file is found, its contents are read and parsed into a JavaScript object.
+ *
+ * @return {Record<string, Object>} The parsed contents of the `package.json` file as a key-value object.
+ */
+export declare function loadCliPackageJson(): Record<string, any>;
+/**
+ * Loads the `package.json` file from the local working directory and parses its content into a JavaScript object.
+ *
+ * @return {Promise<Record<string, Object>>} A promise that resolves to an object representing the contents of the
+ * `package.json` file, where keys and values are strings.
+ */
+export declare function loadLocalPackageJson(): Promise<Record<string, any>>;
+/**
+ * Loads and registers resource models from the specified file pattern.
+ *
+ * This method scans for model files that match the given pattern,
+ * imports them, and checks if they conform to the resource model schema.
+ * Valid models are added to the returned collection.
+ *
+ * @param {string} [modelPattern] - The glob pattern used to locate model files. The default value is used from config.
+ * @return {Promise<Record<string, ResourceModel>>} A promise resolving to an object containing the loaded resource models,
+ * where the keys are the model names and the values are the associated ResourceModel objects.
+ */
+export declare function loadModels(modelPattern: string): Promise<Record<string, ResourceModel>>;

package/utils/loader-util.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCliPackageJson = loadCliPackageJson;
+exports.loadLocalPackageJson = loadLocalPackageJson;
+exports.loadModels = loadModels;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const glob_1 = require("glob");
+const ts_node_1 = require("ts-node");
+const common_1 = require("@appweaver/common");
+/**
+ * Loads and parses the `package.json` file located in the CLI project package directory.
+ * The function attempts to locate the `package.json` file in one of two
+ * predefined directories relative to the current module's directory.
+ * If the file is found, its contents are read and parsed into a JavaScript object.
+ *
+ * @return {Record<string, Object>} The parsed contents of the `package.json` file as a key-value object.
+ */
+function loadCliPackageJson() {
+    const pkgPath = node_path_1.default.join(__dirname, '../package.json');
+    const pkgContent = node_fs_1.default.readFileSync(pkgPath, 'utf8');
+    return JSON.parse(pkgContent);
+}
+/**
+ * Loads the `package.json` file from the local working directory and parses its content into a JavaScript object.
+ *
+ * @return {Promise<Record<string, Object>>} A promise that resolves to an object representing the contents of the
+ * `package.json` file, where keys and values are strings.
+ */
+async function loadLocalPackageJson() {
+    const pkgPath = node_path_1.default.join(process.cwd(), 'package.json');
+    const pkgContent = await promises_1.default.readFile(pkgPath, 'utf-8');
+    return JSON.parse(pkgContent);
+}
+/**
+ * Loads and registers resource models from the specified file pattern.
+ *
+ * This method scans for model files that match the given pattern,
+ * imports them, and checks if they conform to the resource model schema.
+ * Valid models are added to the returned collection.
+ *
+ * @param {string} [modelPattern] - The glob pattern used to locate model files. The default value is used from config.
+ * @return {Promise<Record<string, ResourceModel>>} A promise resolving to an object containing the loaded resource models,
+ * where the keys are the model names and the values are the associated ResourceModel objects.
+ */
+async function loadModels(modelPattern) {
+    const cwd = process.cwd();
+    (0, ts_node_1.register)({
+        transpileOnly: true,
+        compilerOptions: {
+            module: 'CommonJS'
+        }
+    });
+    const models = {};
+    const modelPaths = [];
+    // Add project files using a pattern
+    const projectModelPaths = await (0, glob_1.glob)(modelPattern, { cwd, absolute: true });
+    // Sort is needed since glob returns files in non-deterministic order
+    projectModelPaths.sort();
+    modelPaths.push(...projectModelPaths);
+    // Add exported core module resources
+    modelPaths.push('@appweaver/core/resources');
+    // Add additional modules from config
+    for (const module of common_1.config.APP_AUTOLOAD_MODULES) {
+        modelPaths.push(module);
+    }
+    for (const modelPath of modelPaths) {
+        let modelExport;
+        try {
+            // Clear cache to ensure fresh model data
+            delete require.cache[require.resolve(modelPath)];
+            modelExport = await Promise.resolve(`${modelPath}`).then(s => __importStar(require(s)));
+        }
+        catch (error) {
+            console.log('Cannot load module:', modelPath, '\nError:', error, '\nSkipping...');
+            continue;
+        }
+        const modelSchema = modelExport.default || modelExport;
+        // Add only exports that satisfy the resource model schema requirements
+        if ((0, common_1.isResourceModel)(modelSchema)) {
+            models[modelSchema.name] = modelSchema;
+        }
+        else {
+            for (const maybeSchema of Object.values(modelSchema)) {
+                if ((0, common_1.isResourceModel)(maybeSchema)) {
+                    models[maybeSchema.name] = maybeSchema;
+                }
+            }
+        }
+    }
+    if (Object.keys(models).length === 0) {
+        console.log('No resource models exports found matching pattern:', modelPattern);
+    }
+    return models;
+}

package/utils/path-util.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Computes the relative path from the directory of the first path to the other path.
+ *
+ * @param {string} firstPath - The base path used to calculate the relative path.
+ * @param {string} otherPath - The target path for which the relative path will be calculated.
+ * @return {string} The relative path from the `firstPath` directory to `otherPath`, normalized with forward slashes.
+ */
+export declare function relativePathFrom(firstPath: string, otherPath: string): string;
+/**
+ * Asserts that the `childPath` is located inside the `basePath`. If the condition
+ * is not met, logs the specified error message and terminates the process.
+ *
+ * @param basePath The base directory path to validate against.
+ * @param childPath The path to validate as being inside the `basePath`.
+ * @param message The error message to log if the assertion fails.
+ */
+export declare function assertPathInside(basePath: string, childPath: string, message: string): void;
+/**
+ * Determines whether a given child path is located within a specific base path.
+ *
+ * @param {string} basePath - The base directory path to check against.
+ * @param {string} childPath - The child path to evaluate.
+ * @return {boolean} Returns true if the child path is inside the base path; otherwise, false.
+ */
+export declare function isPathInside(basePath: string, childPath: string): boolean;
+/**
+ * Recursively removes a specified file or directory path.
+ *
+ * @param {string} path - The file or directory path to be removed.
+ * @param {boolean} [quiet=false] - If true, suppresses error logging when an error occurs.
+ * @return {Promise<boolean>} A promise that resolves to `true` if a path is removed, `false` otherwise.
+ */
+export declare function rimrafPath(path: string, quiet?: boolean): Promise<boolean>;
+/**
+ * Ensures that the directory for the given file path exists. If the directory does not exist, it is created
+ * recursively.
+ *
+ * @param {string} filePath - The path of the file whose directory needs to be checked or created.
+ * @return {Promise<void>} A promise that resolves when the directory exists or has been successfully created.
+ */
+export declare function ensureDirExists(filePath: string): Promise<void>;

package/utils/path-util.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativePathFrom = relativePathFrom;
+exports.assertPathInside = assertPathInside;
+exports.isPathInside = isPathInside;
+exports.rimrafPath = rimrafPath;
+exports.ensureDirExists = ensureDirExists;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const rimraf_1 = require("rimraf");
+/**
+ * Computes the relative path from the directory of the first path to the other path.
+ *
+ * @param {string} firstPath - The base path used to calculate the relative path.
+ * @param {string} otherPath - The target path for which the relative path will be calculated.
+ * @return {string} The relative path from the `firstPath` directory to `otherPath`, normalized with forward slashes.
+ */
+function relativePathFrom(firstPath, otherPath) {
+    const schemaDir = node_path_1.default.dirname(node_path_1.default.resolve(firstPath));
+    const clientAbs = node_path_1.default.resolve(otherPath);
+    let rel = node_path_1.default.relative(schemaDir, clientAbs);
+    if (!rel.startsWith('.') && rel !== '') {
+        rel = `.${node_path_1.default.sep}${rel}`;
+    }
+    else if (rel === '') {
+        rel = '.';
+    }
+    return rel.replace(/\\/g, '/');
+}
+/**
+ * Asserts that the `childPath` is located inside the `basePath`. If the condition
+ * is not met, logs the specified error message and terminates the process.
+ *
+ * @param basePath The base directory path to validate against.
+ * @param childPath The path to validate as being inside the `basePath`.
+ * @param message The error message to log if the assertion fails.
+ */
+function assertPathInside(basePath, childPath, message) {
+    if (!isPathInside(basePath, childPath)) {
+        console.error(message);
+        process.exit(1);
+    }
+}
+/**
+ * Determines whether a given child path is located within a specific base path.
+ *
+ * @param {string} basePath - The base directory path to check against.
+ * @param {string} childPath - The child path to evaluate.
+ * @return {boolean} Returns true if the child path is inside the base path; otherwise, false.
+ */
+function isPathInside(basePath, childPath) {
+    const base = node_path_1.default.resolve(basePath);
+    const child = node_path_1.default.resolve(childPath);
+    // Add a trailing separator so `/temp/dir2` is not matched by `/temp/dir`
+    const baseWithSep = base.endsWith(node_path_1.default.sep) ? base : base + node_path_1.default.sep;
+    return child.startsWith(baseWithSep);
+}
+/**
+ * Recursively removes a specified file or directory path.
+ *
+ * @param {string} path - The file or directory path to be removed.
+ * @param {boolean} [quiet=false] - If true, suppresses error logging when an error occurs.
+ * @return {Promise<boolean>} A promise that resolves to `true` if a path is removed, `false` otherwise.
+ */
+async function rimrafPath(path, quiet = false) {
+    try {
+        const result = await (0, rimraf_1.rimraf)(path, { maxRetries: 10, retryDelay: 100 });
+        if (!result && !quiet) {
+            console.error(`Unable to remove path: ${path}`);
+        }
+        return result;
+    }
+    catch (error) {
+        if (!quiet) {
+            console.error(`Error removing path: ${path}`, error);
+        }
+        return false;
+    }
+}
+/**
+ * Ensures that the directory for the given file path exists. If the directory does not exist, it is created
+ * recursively.
+ *
+ * @param {string} filePath - The path of the file whose directory needs to be checked or created.
+ * @return {Promise<void>} A promise that resolves when the directory exists or has been successfully created.
+ */
+async function ensureDirExists(filePath) {
+    const dirPath = node_path_1.default.resolve(node_path_1.default.dirname(filePath));
+    try {
+        await promises_1.default.access(dirPath, promises_1.default.constants.F_OK);
+    }
+    catch (e) {
+        await promises_1.default.mkdir(dirPath, { recursive: true });
+    }
+}

package/utils/process-util.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Executes a shell command with optional arguments and configuration parameters.
+ *
+ * @param {string} cmd - The command to execute.
+ * @param {string[]} [args=[]] - An array of arguments to pass to the command.
+ * @param {Object} [params={ quiet: false }] - Configurations for how the process should run.
+ * @param {boolean} [params.quiet=false] - If true, suppresses the process output.
+ * @param {AbortSignal} [params.signal] - Optional AbortSignal to terminate the running process.
+ * @return {Promise<number>} A promise that resolves with the exit code of the process or 1 on error.
+ */
+export declare function runProcess(cmd: string, args?: string[], params?: {
+    quiet?: boolean;
+    signal?: AbortSignal;
+}): Promise<number>;
+/**
+ * Verifies that the application's runtime environment matches the specified environment.
+ * Terminates the process with an error message if the environments do not match.
+ *
+ * @param {string} env - The expected environment (e.g., 'production', 'development').
+ * @param {string} message - The error message to display if the environment does not match.
+ */
+export declare function assertEnv(env: string, message: string): void;
+/**
+ * Verifies that the application's runtime environment matches one of the specified environments.
+ * Terminates the process with an error message if the environment does not match any of the provided options.
+ *
+ * @param {string[]} envs - An array of expected environments (e.g., ['prod', 'dev', 'test']).
+ * @param {string} message - The error message to display if the environment does not match any of the provided options.
+ */
+export declare function assertEnvs(envs: string[], message: string): void;
+/**
+ * Checks if the current environment is a Bun.js process.
+ *
+ * This method determines whether the global `Bun` object is defined,
+ * which indicates the code is running in a Bun.js runtime environment.
+ *
+ * @return {boolean} Returns `true` if the `Bun` object is defined, otherwise `false`.
+ */
+export declare function isBunProcess(): boolean;