@guiho/runx 0.2.7 → 0.4.0

package/library/init.js

@@ -1,165 +1,43 @@
 /**
  * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
  */
-import { randomUUID } from 'node:crypto';
-import { rename, rm, writeFile } from 'node:fs/promises';
-import { basename, isAbsolute, relative, resolve } from 'node:path';
-import { createInterface } from 'node:readline/promises';
 import { RunXError } from './errors.js';
-import { readManifest } from './manifest.js';
-const manifestVersion = '1.0.0';
-export const initializeRunXManifest = async ({ cwd, isInteractive = process.stdin.isTTY === true && process.stdout.isTTY === true, prompter }) => {
-    if (!isInteractive) {
-        throw new RunXError('runx init requires an interactive terminal. Run it directly in a terminal with stdin and stdout attached.');
-    }
-    const activePrompter = prompter ?? createTerminalPrompter();
-    try {
-        const root = resolve(cwd);
-        const path = resolve(root, 'runx.yaml');
-        const defaultProjectName = basename(root) || 'my-project';
-        activePrompter.intro('RunX project setup');
-        if (await Bun.file(path).exists()) {
-            const overwrite = await activePrompter.confirm({
-                message: 'runx.yaml already exists. Replace it?',
-                initialValue: false,
-            });
-            if (overwrite !== true)
-                return cancelInitialization(activePrompter);
-        }
-        const projectName = await activePrompter.text({
-            message: 'Project name',
-            initialValue: defaultProjectName,
-            validate: (value) => value?.trim() ? undefined : 'Enter a project name.',
-        });
-        if (projectName === undefined)
-            return cancelInitialization(activePrompter);
-        const scriptsDirectory = await activePrompter.text({
-            message: 'Scripts directory',
-            initialValue: 'scripts',
-            validate: (value) => validateScriptsDirectory(value, root),
-        });
-        if (scriptsDirectory === undefined)
-            return cancelInitialization(activePrompter);
-        const manifest = createInitialManifest(projectName.trim(), scriptsDirectory.trim());
-        const yaml = renderInitialManifest(manifest);
-        activePrompter.preview(yaml);
-        const confirmed = await activePrompter.confirm({
-            message: 'Create this runx.yaml?',
-            initialValue: true,
-        });
-        if (confirmed !== true)
-            return cancelInitialization(activePrompter);
-        await writeValidatedManifest(root, path, yaml);
-        activePrompter.outro(`Created ${path}`);
-        return { status: 'created', path, manifest };
-    }
-    finally {
-        activePrompter.close?.();
-    }
-};
-export const createInitialManifest = (projectName, scriptsDirectory) => ({
-    version: manifestVersion,
-    project: { name: projectName },
-    scripts: { directory: scriptsDirectory },
-    groups: {
-        public: { summary: 'Default public project commands.' },
-    },
-    commands: [],
-});
-export const renderInitialManifest = (manifest) => [
-    `version: ${JSON.stringify(manifest.version)}`,
-    '',
-    'project:',
-    `  name: ${JSON.stringify(manifest.project?.name ?? '')}`,
-    '',
-    'scripts:',
-    `  directory: ${JSON.stringify(manifest.scripts.directory)}`,
-    '',
-    'groups:',
-    '  public:',
-    `    summary: ${JSON.stringify(manifest.groups.public.summary)}`,
-    '',
-    'commands: []',
-    '',
-].join('\n');
-const createTerminalPrompter = () => {
-    const terminal = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-    const accent = (value) => process.env['NO_COLOR'] ? value : `\u001b[36m${value}\u001b[0m`;
-    const success = (value) => process.env['NO_COLOR'] ? value : `\u001b[32m${value}\u001b[0m`;
-    const muted = (value) => process.env['NO_COLOR'] ? value : `\u001b[2m${value}\u001b[0m`;
-    const error = (value) => process.env['NO_COLOR'] ? value : `\u001b[31m${value}\u001b[0m`;
-    const write = (value) => {
-        process.stdout.write(value);
-    };
-    const ask = async (label) => {
-        try {
-            return await terminal.question(label);
-        }
-        catch {
-            return undefined;
-        }
-    };
+import { baseName, resolvePath } from './path-utils.js';
+import { writeTextFile } from './storage.js';
+export { createInitialManifest, initializeRunXManifest, renderInitialManifest, };
+async function initializeRunXManifest(options) {
+    const cwd = resolvePath(options.cwd);
+    const path = resolvePath(cwd, options.config ?? 'runx.yaml');
+    if (await Bun.file(path).exists())
+        throw new RunXError(`Configuration already exists: ${path}`, 5);
+    const manifest = createInitialManifest(baseName(cwd) || 'my-project', 'scripts');
+    await writeTextFile(path, renderInitialManifest(manifest));
+    return { status: 'created', path, manifest };
+}
+function createInitialManifest(projectName, scriptsDirectory) {
     return {
-        intro: (title) => write(`\n${accent('◆')} ${title}\n${muted('  A documented command catalog for this project.')}\n\n`),
-        text: async (options) => {
-            while (true) {
-                const value = await ask(`${accent('◆')} ${options.message} ${muted(`[${options.initialValue}]`)}\n  `);
-                if (value === undefined)
-                    return undefined;
-                const selected = value.trim() || options.initialValue;
-                const validation = options.validate(selected);
-                if (!validation)
-                    return selected;
-                write(`${error('▲')} ${validation}\n`);
-            }
-        },
-        confirm: async (options) => {
-            while (true) {
-                const defaultLabel = options.initialValue ? 'Y/n' : 'y/N';
-                const value = await ask(`${accent('◆')} ${options.message} ${muted(`[${defaultLabel}]`)}\n  `);
-                if (value === undefined)
-                    return undefined;
-                const answer = value.trim().toLowerCase();
-                if (!answer)
-                    return options.initialValue;
-                if (answer === 'y' || answer === 'yes')
-                    return true;
-                if (answer === 'n' || answer === 'no')
-                    return false;
-                write(`${error('▲')} Enter yes or no.\n`);
-            }
-        },
-        preview: (manifest) => write(`\n${accent('┌─ runx.yaml preview ─────────────────────────────────')}\n${manifest.trimEnd().split('\n').map((line) => `${accent('│')} ${line}`).join('\n')}\n${accent('└────────────────────────────────────────────────────')}\n\n`),
-        cancel: (message) => write(`${error('■')} ${message}\n`),
-        outro: (message) => {
-            write(`${success('◆')} ${message}\n`);
-        },
-        close: () => terminal.close(),
+        version: '1.0.0',
+        project: { name: projectName },
+        scripts: { directory: scriptsDirectory },
+        groups: { public: { summary: 'Default public project commands.' } },
+        commands: [],
     };
-};
-const cancelInitialization = (prompter) => {
-    prompter.cancel('Initialization cancelled. No files were changed.');
-    return { status: 'cancelled' };
-};
-const validateScriptsDirectory = (value, root) => {
-    const directory = value?.trim();
-    if (!directory)
-        return 'Enter a scripts directory.';
-    const resolvedDirectory = resolve(root, directory);
-    const relativeDirectory = relative(root, resolvedDirectory);
-    if (relativeDirectory === '' || relativeDirectory === '.' || isAbsolute(relativeDirectory) || relativeDirectory.startsWith('..')) {
-        return 'Use a relative subdirectory inside this project.';
-    }
-    return undefined;
-};
-const writeValidatedManifest = async (root, path, yaml) => {
-    const temporaryPath = resolve(root, `.runx-${randomUUID()}.yaml.tmp`);
-    try {
-        await writeFile(temporaryPath, yaml, { encoding: 'utf8', flag: 'wx' });
-        await readManifest(root, temporaryPath);
-        await rename(temporaryPath, path);
-    }
-    finally {
-        await rm(temporaryPath, { force: true });
-    }
-};
+}
+function renderInitialManifest(manifest) {
+    return [
+        `version: ${JSON.stringify(manifest.version)}`,
+        '',
+        'project:',
+        `  name: ${JSON.stringify(manifest.project?.name ?? '')}`,
+        '',
+        'scripts:',
+        `  directory: ${JSON.stringify(manifest.scripts.directory)}`,
+        '',
+        'groups:',
+        '  public:',
+        `    summary: ${JSON.stringify(manifest.groups.public.summary)}`,
+        '',
+        'commands: []',
+        '',
+    ].join('\n');
+}

package/library/manifest.d.ts

@@ -1,44 +1,5 @@
-import type { ResolvedCommand, RunXManifest } from './types.js';
-export declare const CommandSchema: import("@sinclair/typebox").TObject<{
-    uid: import("@sinclair/typebox").TString;
-    id: import("@sinclair/typebox").TString;
-    group: import("@sinclair/typebox").TString;
-    summary: import("@sinclair/typebox").TString;
-    description: import("@sinclair/typebox").TString;
-    command: import("@sinclair/typebox").TString;
-    cwd: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    shell: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"auto">, import("@sinclair/typebox").TLiteral<"bash">, import("@sinclair/typebox").TLiteral<"sh">, import("@sinclair/typebox").TLiteral<"powershell">, import("@sinclair/typebox").TLiteral<"cmd">]>>;
-    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    confirm: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"never">, import("@sinclair/typebox").TLiteral<"always">]>>;
-}>;
-export declare const ManifestSchema: import("@sinclair/typebox").TObject<{
-    version: import("@sinclair/typebox").TString;
-    project: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        name: import("@sinclair/typebox").TString;
-    }>>;
-    scripts: import("@sinclair/typebox").TObject<{
-        directory: import("@sinclair/typebox").TString;
-    }>;
-    groups: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
-        summary: import("@sinclair/typebox").TString;
-    }>>;
-    commands: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        uid: import("@sinclair/typebox").TString;
-        id: import("@sinclair/typebox").TString;
-        group: import("@sinclair/typebox").TString;
-        summary: import("@sinclair/typebox").TString;
-        description: import("@sinclair/typebox").TString;
-        command: import("@sinclair/typebox").TString;
-        cwd: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        shell: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"auto">, import("@sinclair/typebox").TLiteral<"bash">, import("@sinclair/typebox").TLiteral<"sh">, import("@sinclair/typebox").TLiteral<"powershell">, import("@sinclair/typebox").TLiteral<"cmd">]>>;
-        tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-        confirm: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"never">, import("@sinclair/typebox").TLiteral<"always">]>>;
-    }>>;
-}>;
-export declare const findManifest: (cwd: string, explicitFile?: string) => Promise<string>;
-export declare const readManifest: (cwd: string, explicitFile?: string) => Promise<{
-    manifest: RunXManifest;
-    path: string;
-}>;
-export declare const resolveCommand: (manifest: RunXManifest, manifestPath: string, selector: string) => ResolvedCommand;
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { commandSchema as CommandSchema, findConfiguration as findManifest, manifestSchema as ManifestSchema, readManifest, resolveCommand, } from './configuration.js';
 //# sourceMappingURL=manifest.d.ts.map

package/library/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../source/manifest.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAe,YAAY,EAAE,MAAM,YAAY,CAAA;AAK5E,eAAO,MAAM,aAAa;;;;;;;;;;;EAiBS,CAAA;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;EAMQ,CAAA;AAInC,eAAO,MAAM,YAAY,QAAe,MAAM,iBAAiB,MAAM,KAAG,OAAO,CAAC,MAAM,CAiBrF,CAAA;AAED,eAAO,MAAM,YAAY,QAAe,MAAM,iBAAiB,MAAM,KAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAmBvH,CAAA;AAED,eAAO,MAAM,cAAc,aAAc,YAAY,gBAAgB,MAAM,YAAY,MAAM,KAAG,eAkC/F,CAAA"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../source/manifest.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,aAAa,IAAI,aAAa,EAC9B,iBAAiB,IAAI,YAAY,EACjC,cAAc,IAAI,cAAc,EAChC,YAAY,EACZ,cAAc,GACf,MAAM,oBAAoB,CAAA"}

package/library/manifest.js

@@ -1,125 +1,4 @@
-import { dirname, isAbsolute, relative, resolve } from 'node:path';
-import { Type } from '@sinclair/typebox';
-import { TypeCompiler } from '@sinclair/typebox/compiler';
-import { RunXError, invariant } from './errors.js';
-const identifier = '^[a-z][a-z0-9-]*$';
-const semver = '^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$';
-export const CommandSchema = Type.Object({
-    uid: Type.String({ pattern: identifier }),
-    id: Type.String({ pattern: identifier }),
-    group: Type.String({ pattern: identifier }),
-    summary: Type.String({ minLength: 1 }),
-    description: Type.String({ minLength: 1 }),
-    command: Type.String({ minLength: 1 }),
-    cwd: Type.Optional(Type.String({ minLength: 1 })),
-    shell: Type.Optional(Type.Union([
-        Type.Literal('auto'),
-        Type.Literal('bash'),
-        Type.Literal('sh'),
-        Type.Literal('powershell'),
-        Type.Literal('cmd'),
-    ])),
-    tags: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    confirm: Type.Optional(Type.Union([Type.Literal('never'), Type.Literal('always')])),
-}, { additionalProperties: false });
-export const ManifestSchema = Type.Object({
-    version: Type.String({ pattern: semver }),
-    project: Type.Optional(Type.Object({ name: Type.String({ minLength: 1 }) }, { additionalProperties: false })),
-    scripts: Type.Object({ directory: Type.String({ minLength: 1 }) }, { additionalProperties: false }),
-    groups: Type.Record(Type.String({ pattern: identifier }), Type.Object({ summary: Type.String({ minLength: 1 }) }, { additionalProperties: false })),
-    commands: Type.Array(CommandSchema),
-}, { additionalProperties: false });
-const manifestCheck = TypeCompiler.Compile(ManifestSchema);
-export const findManifest = async (cwd, explicitFile) => {
-    if (explicitFile) {
-        const candidate = resolve(cwd, explicitFile);
-        if (await Bun.file(candidate).exists())
-            return candidate;
-        throw new RunXError(`Manifest not found: ${candidate}`);
-    }
-    let current = resolve(cwd);
-    while (true) {
-        const candidate = resolve(current, 'runx.yaml');
-        if (await Bun.file(candidate).exists())
-            return candidate;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    throw new RunXError('No runx.yaml found. Run this command inside a configured project or pass --file <path>.');
-};
-export const readManifest = async (cwd, explicitFile) => {
-    const path = await findManifest(cwd, explicitFile);
-    let parsed;
-    try {
-        parsed = Bun.YAML.parse(await Bun.file(path).text());
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : 'Unknown YAML parsing error.';
-        throw new RunXError(`Invalid YAML in ${path}: ${message}`);
-    }
-    if (!manifestCheck.Check(parsed)) {
-        const errors = [...manifestCheck.Errors(parsed)].map((error) => `${error.path || '/'}: ${error.message}`);
-        throw new RunXError(`Invalid RunX manifest ${path}:\n${errors.join('\n')}`);
-    }
-    const manifest = parsed;
-    validateManifestSemantics(manifest, path);
-    return { manifest, path };
-};
-export const resolveCommand = (manifest, manifestPath, selector) => {
-    const commands = manifest.commands;
-    let command = commands.find((entry) => entry.uid === selector);
-    if (!command && selector.includes('/')) {
-        command = commands.find((entry) => `${entry.group}/${entry.id}` === selector);
-    }
-    if (!command && /^\d+$/.test(selector)) {
-        command = commands[Number.parseInt(selector, 10) - 1];
-    }
-    if (!command) {
-        const matches = commands.filter((entry) => entry.id === selector);
-        if (matches.length > 1) {
-            throw new RunXError(`Ambiguous command ID "${selector}". Use one of: ${matches.map((entry) => `${entry.group}/${entry.id} (${entry.uid})`).join(', ')}`);
-        }
-        command = matches[0];
-    }
-    if (!command)
-        throw new RunXError(`Unknown command selector: ${selector}`);
-    const manifestDirectory = dirname(manifestPath);
-    const commandCwd = resolve(manifestDirectory, command.cwd ?? '.');
-    const relativeCwd = relative(manifestDirectory, commandCwd);
-    invariant(!isAbsolute(relativeCwd) && !relativeCwd.startsWith('..'), `Command ${command.uid} has a cwd outside the manifest directory.`);
-    return {
-        ...command,
-        index: commands.indexOf(command) + 1,
-        selector: `${command.group}/${command.id}`,
-        manifestPath,
-        cwd: commandCwd,
-    };
-};
-const validateManifestSemantics = (manifest, path) => {
-    const versionMajor = manifest.version.split('.', 1)[0];
-    if (versionMajor !== '1') {
-        throw new RunXError(`Unsupported RunX manifest version "${manifest.version}" in ${path}. Supported major version: 1.`);
-    }
-    const manifestDirectory = dirname(path);
-    const scriptsDirectory = resolve(manifestDirectory, manifest.scripts.directory);
-    const relativeScriptsDirectory = relative(manifestDirectory, scriptsDirectory);
-    invariant(relativeScriptsDirectory !== '' && relativeScriptsDirectory !== '.' && !isAbsolute(relativeScriptsDirectory) && !relativeScriptsDirectory.startsWith('..'), `Scripts directory "${manifest.scripts.directory}" must be a relative subdirectory inside the manifest directory in ${path}.`);
-    if (!manifest.groups.public) {
-        throw new RunXError(`RunX manifest ${path} must define the default "public" group.`);
-    }
-    const uids = new Set();
-    const selectors = new Set();
-    for (const command of manifest.commands) {
-        if (!manifest.groups[command.group])
-            throw new RunXError(`Command ${command.uid} references unknown group "${command.group}" in ${path}.`);
-        if (uids.has(command.uid))
-            throw new RunXError(`Duplicate command UID "${command.uid}" in ${path}.`);
-        const selector = `${command.group}/${command.id}`;
-        if (selectors.has(selector))
-            throw new RunXError(`Duplicate command selector "${selector}" in ${path}.`);
-        uids.add(command.uid);
-        selectors.add(selector);
-    }
-};
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { commandSchema as CommandSchema, findConfiguration as findManifest, manifestSchema as ManifestSchema, readManifest, resolveCommand, } from './configuration.js';

package/library/path-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { baseName, directoryName, homeDirectory, isAbsolutePath, joinPath, normalizePath, relativePath, resolvePath, };
+declare function normalizePath(value: string): string;
+declare function isAbsolutePath(value: string): boolean;
+declare function resolvePath(...values: string[]): string;
+declare function joinPath(...values: string[]): string;
+declare function directoryName(value: string): string;
+declare function baseName(value: string): string;
+declare function relativePath(from: string, to: string): string;
+declare function homeDirectory(): string;
+//# sourceMappingURL=path-utils.d.ts.map

package/library/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../source/path-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,EACd,QAAQ,EACR,aAAa,EACb,YAAY,EACZ,WAAW,GACZ,CAAA;AAQD,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAoB5C;AAED,iBAAS,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,iBAAS,WAAW,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAQhD;AAED,iBAAS,QAAQ,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7C;AAED,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ5C;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIvC;AAED,iBAAS,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAYtD;AAED,iBAAS,aAAa,IAAI,MAAM,CAI/B"}

package/library/path-utils.js

@@ -0,0 +1,82 @@
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { baseName, directoryName, homeDirectory, isAbsolutePath, joinPath, normalizePath, relativePath, resolvePath, };
+const windowsDrivePattern = /^[A-Za-z]:[\\/]/;
+function pathSeparator(value = process.platform) {
+    return value === 'win32' ? '\\' : '/';
+}
+function normalizePath(value) {
+    const separator = pathSeparator();
+    const normalized = value.replace(/[\\/]+/g, separator);
+    const drive = windowsDrivePattern.test(normalized) ? normalized.slice(0, 2) : '';
+    const rooted = drive !== '' || normalized.startsWith(separator);
+    const parts = normalized.slice(drive.length).split(separator);
+    const output = [];
+    for (const part of parts) {
+        if (!part || part === '.')
+            continue;
+        if (part === '..') {
+            if (output.length > 0 && output.at(-1) !== '..')
+                output.pop();
+            else if (!rooted)
+                output.push(part);
+            continue;
+        }
+        output.push(part);
+    }
+    const prefix = drive ? `${drive}${separator}` : rooted ? separator : '';
+    return `${prefix}${output.join(separator)}` || (rooted ? prefix : '.');
+}
+function isAbsolutePath(value) {
+    return windowsDrivePattern.test(value) || value.startsWith('/') || value.startsWith('\\');
+}
+function resolvePath(...values) {
+    let current = '';
+    for (const value of values) {
+        if (!value)
+            continue;
+        current = isAbsolutePath(value) ? value : current ? joinPath(current, value) : value;
+    }
+    if (!isAbsolutePath(current))
+        current = joinPath(process.cwd(), current);
+    return normalizePath(current);
+}
+function joinPath(...values) {
+    return normalizePath(values.filter(Boolean).join(pathSeparator()));
+}
+function directoryName(value) {
+    const normalized = normalizePath(value);
+    const separator = pathSeparator();
+    const index = normalized.lastIndexOf(separator);
+    if (index < 0)
+        return '.';
+    if (index === 0)
+        return separator;
+    if (index === 2 && windowsDrivePattern.test(normalized))
+        return normalized.slice(0, 3);
+    return normalized.slice(0, index);
+}
+function baseName(value) {
+    const normalized = normalizePath(value);
+    const index = normalized.lastIndexOf(pathSeparator());
+    return index < 0 ? normalized : normalized.slice(index + 1);
+}
+function relativePath(from, to) {
+    const separator = pathSeparator();
+    const fromParts = normalizePath(from).split(separator);
+    const toParts = normalizePath(to).split(separator);
+    const insensitive = process.platform === 'win32';
+    let index = 0;
+    while (index < fromParts.length
+        && index < toParts.length
+        && (insensitive ? fromParts[index].toLowerCase() === toParts[index].toLowerCase() : fromParts[index] === toParts[index]))
+        index += 1;
+    return [...Array(fromParts.length - index).fill('..'), ...toParts.slice(index)].join(separator) || '.';
+}
+function homeDirectory() {
+    const home = Bun.env.HOME ?? Bun.env.USERPROFILE;
+    if (!home)
+        throw new Error('RunX requires HOME or USERPROFILE to resolve global storage.');
+    return resolvePath(home);
+}

package/library/recovery.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { RecoveryInstructions, UpgradeOs } from './upgrade-types.js';
+export { createRecoveryInstructions };
+declare const createRecoveryInstructions: (targetVersion: string, os: UpgradeOs, targetSource?: RecoveryInstructions['targetSource'], installerBaseUrl?: string) => RecoveryInstructions;
+//# sourceMappingURL=recovery.d.ts.map

package/library/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../source/recovery.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEzE,OAAO,EAAE,0BAA0B,EAAE,CAAA;AAIrC,QAAA,MAAM,0BAA0B,kBAAmB,MAAM,MAAM,SAAS,iBAAgB,oBAAoB,CAAC,cAAc,CAAC,gCAA4C,oBAevK,CAAA"}

package/library/recovery.js

@@ -0,0 +1,23 @@
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+export { createRecoveryInstructions };
+const rawBase = 'https://raw.githubusercontent.com/CGuiho/runx/main/devops';
+const createRecoveryInstructions = (targetVersion, os, targetSource = 'resolved', installerBaseUrl = rawBase) => {
+    if (os === 'windows') {
+        return {
+            targetVersion,
+            targetSource,
+            installCommand: `powershell.exe -NoProfile -ExecutionPolicy Bypass -Command '& ([scriptblock]::Create((Invoke-RestMethod "${installerBaseUrl}/install.ps1"))) -Version "${escapePowerShell(targetVersion)}"'`,
+            stopProcessCommand: 'powershell.exe -NoProfile -Command "Get-Process runx -ErrorAction SilentlyContinue | Stop-Process -Force"',
+        };
+    }
+    return {
+        targetVersion,
+        targetSource,
+        installCommand: `curl -fsSL ${installerBaseUrl}/install.sh | sh -s -- --version '${escapeShell(targetVersion)}'`,
+        stopProcessCommand: 'pkill -x runx',
+    };
+};
+const escapePowerShell = (value) => value.replace(/`/g, '``').replace(/"/g, '`"');
+const escapeShell = (value) => value.replace(/'/g, `'"'"'`);

package/library/release-catalog.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @copyright Copyright © 2026 GUIHO Technologies as represented by Cristóvão GUIHO. All Rights Reserved.
+ */
+import type { ReleaseAsset, ReleaseCatalog, UpgradeArch, UpgradeOs, UpgradeVariant } from './upgrade-types.js';
+export { assetCandidates, fetchReleaseCatalog, findCompatibleAsset, normalizeReleaseVersion, resolveUpgradePlatform, };
+declare const githubReleaseSchema: import("@sinclair/typebox").TObject<{
+    tag_name: import("@sinclair/typebox").TString;
+    draft: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    prerelease: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    published_at: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+    created_at: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+    assets: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        browser_download_url: import("@sinclair/typebox").TString;
+    }>>;
+}>;
+export type GitHubRelease = import('@sinclair/typebox').Static<typeof githubReleaseSchema>;
+export type ReleasePlatform = {
+    os: UpgradeOs;
+    arch: UpgradeArch;
+    variant: UpgradeVariant;
+};
+type FetchCatalogOptions = ReleasePlatform & {
+    currentVersion: string;
+    fetchImpl?: typeof fetch;
+};
+declare const fetchReleaseCatalog: (options: FetchCatalogOptions) => Promise<ReleaseCatalog>;
+declare const findCompatibleAsset: (release: GitHubRelease, platform: ReleasePlatform) => ReleaseAsset | null;
+declare const assetCandidates: ({ os, arch, variant }: ReleasePlatform) => string[];
+declare const resolveUpgradePlatform: (platform?: NodeJS.Platform, architecture?: NodeJS.Architecture) => ReleasePlatform;
+declare const normalizeReleaseVersion: (tag: string) => string;
+//# sourceMappingURL=release-catalog.d.ts.map

package/library/release-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-catalog.d.ts","sourceRoot":"","sources":["../source/release-catalog.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAuB,WAAW,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEnI,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,GACvB,CAAA;AAED,QAAA,MAAM,mBAAmB;;;;;;;;;;EAUS,CAAA;AAIlC,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,EAAE,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,cAAc,CAAA;CACxB,CAAA;AAED,KAAK,mBAAmB,GAAG,eAAe,GAAG;IAC3C,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;CACzB,CAAA;AAID,QAAA,MAAM,mBAAmB,YAAmB,mBAAmB,KAAG,OAAO,CAAC,cAAc,CAoCvF,CAAA;AAkBD,QAAA,MAAM,mBAAmB,YAAa,aAAa,YAAY,eAAe,KAAG,YAAY,GAAG,IAM/F,CAAA;AAED,QAAA,MAAM,eAAe,0BAA2B,eAAe,KAAG,MAAM,EAUvE,CAAA;AAED,QAAA,MAAM,sBAAsB,sEAA+D,eAM1F,CAAA;AAED,QAAA,MAAM,uBAAuB,QAAS,MAAM,KAAG,MAA6D,CAAA"}