mb-run 0.0.1-dev-20260504-b6b8a3a

package/dist/module.js

@@ -0,0 +1,233 @@
+import path from 'node:path';
+import process from 'node:process';
+import { clearEnd, getElapsed, green, log, moveUp, savePos, shouldUseAnsi } from './ansi.js';
+import { runBin, runWorkspaceBuild } from './build.js';
+import { cleanOnly, fileExists, resetClean } from './clean.js';
+import { runEsbuild } from './esbuild.js';
+import { printUsage, printVersionUsage } from './help.js';
+import { isPlugin } from './helpers.js';
+import { systemInfo } from './info.js';
+import { initLogger } from './logger.js';
+import { runPack } from './pack.js';
+import { runPublish } from './publish.js';
+import { sortAll } from './sort.js';
+import { ExitError, runCommand } from './spawn.js';
+import { runUpdate } from './update.js';
+import { parseVersionTag, updateRootVersion, updateWorkspaceDependencyVersions } from './version.js';
+const isWindows = process.platform === 'win32';
+export async function main() {
+    const repoRoot = process.cwd();
+    const rawArgs = process.argv.slice(2);
+    if (!(await fileExists(path.join(repoRoot, 'package.json')))) {
+        printUsage();
+        throw new ExitError(1, `No package.json found in current working directory: ${repoRoot}`);
+    }
+    if (rawArgs.length === 0) {
+        printUsage();
+        throw new ExitError(1, 'No arguments provided');
+    }
+    if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+        printUsage();
+        return;
+    }
+    const known = new Set([
+        '--build',
+        '--production',
+        '--install',
+        '--clean',
+        '--watch',
+        '--test',
+        '--lint',
+        '--lint-fix',
+        '--format',
+        '--format-check',
+        '--dry-run',
+        '--sort',
+        '--update',
+        '--reset',
+        '--deep-clean',
+        '--version',
+        '--pack',
+        '--publish',
+        '--esbuild',
+        '--verbose',
+        '--info',
+        '--help',
+        '-h',
+    ]);
+    const dryRunMode = rawArgs.includes('--dry-run');
+    const verboseCommands = rawArgs.includes('--verbose');
+    initLogger({ dryRun: dryRunMode, verbose: verboseCommands, rootDir: repoRoot });
+    const restorePos = (rows = 1) => (rows > 0 && shouldUseAnsi() && !dryRunMode && !verboseCommands ? moveUp(rows) : '');
+    const buildOpts = { rootDir: repoRoot, isWindows, dryRun: dryRunMode };
+    const versionIndex = rawArgs.indexOf('--version');
+    const candidateVersionArg = versionIndex >= 0 ? rawArgs[versionIndex + 1] : undefined;
+    const rawVersionTag = typeof candidateVersionArg === 'string' && !candidateVersionArg.startsWith('-') ? candidateVersionArg : undefined;
+    const unknownFlags = rawArgs.filter((a) => a.startsWith('-') && !known.has(a));
+    if (unknownFlags.length > 0) {
+        printUsage();
+        throw new ExitError(1, `Unknown argument(s): ${unknownFlags.join(' ')}`);
+    }
+    const unknownPositionals = rawArgs.filter((a, i) => !a.startsWith('-') && !(versionIndex >= 0 && rawVersionTag !== undefined && i === versionIndex + 1));
+    if (unknownPositionals.length > 0) {
+        printUsage();
+        throw new ExitError(1, `Unknown argument(s): ${unknownPositionals.join(' ')}`);
+    }
+    let versionTag = null;
+    if (versionIndex >= 0 && rawVersionTag !== undefined) {
+        try {
+            versionTag = parseVersionTag(rawVersionTag);
+        }
+        catch {
+            printVersionUsage();
+            throw new ExitError(1, 'Invalid --version usage');
+        }
+    }
+    const want = {
+        install: rawArgs.includes('--install'),
+        clean: rawArgs.includes('--clean'),
+        build: rawArgs.includes('--build'),
+        production: rawArgs.includes('--production'),
+        version: rawArgs.includes('--version'),
+        watch: rawArgs.includes('--watch'),
+        test: rawArgs.includes('--test'),
+        lint: rawArgs.includes('--lint'),
+        lintFix: rawArgs.includes('--lint-fix'),
+        format: rawArgs.includes('--format'),
+        formatCheck: rawArgs.includes('--format-check'),
+        sort: rawArgs.includes('--sort'),
+        update: rawArgs.includes('--update'),
+        reset: rawArgs.includes('--reset'),
+        deepClean: rawArgs.includes('--deep-clean'),
+        pack: rawArgs.includes('--pack'),
+        publish: rawArgs.includes('--publish'),
+        esbuild: rawArgs.includes('--esbuild'),
+        info: rawArgs.includes('--info'),
+    };
+    if (want.info) {
+        systemInfo();
+    }
+    if (want.update) {
+        want.install = false;
+    }
+    if (want.reset) {
+        want.install = false;
+        want.deepClean = false;
+        want.clean = false;
+        want.build = false;
+    }
+    if (want.install) {
+        log(`${savePos()}⏳ Installing...`);
+        await runCommand('npm', ['install', '--no-fund', '--no-audit', '--silent'], { dryRun: dryRunMode });
+        if (await isPlugin(repoRoot))
+            await runCommand('npm', ['link', 'matterbridge', '--no-fund', '--no-audit', '--silent'], { cwd: repoRoot, dryRun: dryRunMode });
+        log(`${restorePos()}${green('✅')} Install complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.update) {
+        log(`${savePos()}⏳ Updating dependencies...`);
+        await runUpdate(buildOpts);
+        await runCommand('npm', ['install', '--no-fund', '--no-audit', '--silent'], { dryRun: dryRunMode });
+        if (await isPlugin(repoRoot))
+            await runCommand('npm', ['link', 'matterbridge', '--no-fund', '--no-audit', '--silent'], { cwd: repoRoot, dryRun: dryRunMode });
+        log(`${restorePos()}${green('✅')} Update complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.deepClean) {
+        log(`${savePos()}⏳ Deep cleaning...`);
+        await resetClean({ rootDir: repoRoot, dryRun: dryRunMode });
+        log(`${restorePos()}${green('✅')} Deep clean complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.reset) {
+        log(`${savePos()}⏳ Cleaning...`);
+        await resetClean({ rootDir: repoRoot, dryRun: dryRunMode });
+        log(`${restorePos()}⏳ Installing...`);
+        await runCommand('npm', ['install', '--no-fund', '--no-audit', '--silent'], { dryRun: dryRunMode });
+        if (await isPlugin(repoRoot)) {
+            log(`${restorePos()}⏳ Linking...`);
+            await runCommand('npm', ['link', 'matterbridge', '--no-fund', '--no-audit', '--silent'], { cwd: repoRoot, dryRun: dryRunMode });
+        }
+        log(`${restorePos()}⏳ Building...`);
+        await runWorkspaceBuild({ ...buildOpts, mode: want.production ? 'production' : 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Reset complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.version) {
+        log(`${savePos()}⏳ Versioning...`);
+        const versionOpts = { rootDir: repoRoot, dryRun: dryRunMode };
+        const nextVersion = await updateRootVersion(versionTag, versionOpts);
+        await updateWorkspaceDependencyVersions(nextVersion, versionOpts);
+        await runCommand('npm', ['install', '--package-lock-only', '--ignore-scripts', '--no-audit', '--no-fund', '--prefer-offline', '--silent'], {
+            cwd: repoRoot,
+            dryRun: dryRunMode,
+        });
+        log(`${restorePos()}${green('✅')} Versioning to ${nextVersion} complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.clean) {
+        log(`${savePos()}⏳ Cleaning...`);
+        await cleanOnly({ rootDir: repoRoot, dryRun: dryRunMode });
+        log(`${restorePos()}${green('✅')} Clean complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.build && want.production) {
+        log(`${savePos()}⏳ Building for production...`);
+        await runWorkspaceBuild({ ...buildOpts, mode: 'production', watch: false });
+        log(`${restorePos()}${green('✅')} Build for production complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    else if (want.build) {
+        log(`${savePos()}⏳ Building...`);
+        await runWorkspaceBuild({ ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Build complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.test) {
+        log(`${savePos()}⏳ Testing...`);
+        await runBin('jest', ['--maxWorkers=100%'], { ...buildOpts, mode: 'build', watch: false }, {
+            env: {
+                NODE_OPTIONS: '--experimental-vm-modules --no-warnings',
+            },
+        });
+        log(`${restorePos()}${green('✅')} Tests complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.format) {
+        log(`${savePos()}⏳ Formatting...`);
+        await runBin('prettier', ['--log-level=silent', '--cache', '--cache-location', '.cache/.prettiercache', '--write', '.'], { ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Format complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    else if (want.formatCheck) {
+        log(`${savePos()}⏳ Checking format...`);
+        await runBin('prettier', ['--log-level=silent', '--cache', '--cache-location', '.cache/.prettiercache', '--check', '.'], { ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Format check complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.lintFix) {
+        log(`${savePos()}⏳ Linting with fix...`);
+        await runBin('eslint', ['--cache', '--cache-location', '.cache/.eslintcache', '--fix', '--max-warnings=0', '.'], { ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Lint fix complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    else if (want.lint) {
+        log(`${savePos()}⏳ Linting...`);
+        await runBin('eslint', ['--cache', '--cache-location', '.cache/.eslintcache', '--max-warnings=0', '.'], { ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Lint complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.sort) {
+        log(`${savePos()}⏳ Sorting package.json files...`);
+        if (!dryRunMode) {
+            await sortAll(repoRoot);
+        }
+        await runBin('prettier', ['--log-level=silent', '--cache', '--cache-location', '.cache/.prettiercache', '--write', '.'], { ...buildOpts, mode: 'build', watch: false });
+        log(`${restorePos()}${green('✅')} Sort complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.pack) {
+        log(`${savePos()}⏳ Packing...`);
+        await runPack(buildOpts);
+        log(`${restorePos(0)}${green('✅')} Pack complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.publish) {
+        log(`${savePos()}⏳ Publishing...`);
+        await runPublish({ rootDir: repoRoot, isWindows, dryRun: dryRunMode });
+        log(`${restorePos(0)}${green('✅')} Publish complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.esbuild) {
+        log(`${savePos()}⏳ Bundling with esbuild...`);
+        await runEsbuild(buildOpts);
+        log(`${restorePos()}${green('✅')} Esbuild complete in ${getElapsed()}.${clearEnd()}`);
+    }
+    if (want.watch) {
+        await runWorkspaceBuild({ ...buildOpts, mode: 'build', watch: true });
+    }
+}

package/dist/pack.js

@@ -0,0 +1,84 @@
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { runBin, runWorkspaceBuild } from './build.js';
+import { backup, resolveWorkspacePackageJsonPaths, restore } from './cache.js';
+import { cleanOnly, emptyDir } from './clean.js';
+import { runEsbuild } from './esbuild.js';
+import { isPlugin } from './helpers.js';
+import { logDelete, logWriteFile } from './logger.js';
+import { runCommand } from './spawn.js';
+async function removeFile(filePath, opts) {
+    logDelete(filePath);
+    if (opts.dryRun)
+        return;
+    await rm(filePath, { force: true });
+}
+export async function runPack(opts) {
+    const packageJsonPath = path.join(opts.rootDir, 'package.json');
+    if (!opts.dryRun) {
+        await backup(opts.rootDir);
+    }
+    try {
+        await cleanOnly({ rootDir: opts.rootDir, dryRun: opts.dryRun });
+        await runWorkspaceBuild({ rootDir: opts.rootDir, isWindows: opts.isWindows, dryRun: opts.dryRun, mode: 'production', watch: false });
+        await runEsbuild({ rootDir: opts.rootDir, isWindows: opts.isWindows, dryRun: opts.dryRun });
+        logWriteFile(packageJsonPath);
+        if (!opts.dryRun) {
+            const raw = await readFile(packageJsonPath, 'utf8');
+            const pkg = JSON.parse(raw);
+            delete pkg['devDependencies'];
+            delete pkg['scripts'];
+            await writeFile(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+        }
+        const workspacePkgPaths = await resolveWorkspacePackageJsonPaths(opts.rootDir);
+        if (!opts.dryRun && workspacePkgPaths.length > 0) {
+            const raw = await readFile(packageJsonPath, 'utf8');
+            const pkg = JSON.parse(raw);
+            const rootDeps = (pkg['dependencies'] ?? {});
+            for (const wPkgPath of workspacePkgPaths) {
+                const wRaw = await readFile(wPkgPath, 'utf8');
+                const wPkg = JSON.parse(wRaw);
+                for (const [dep, ver] of Object.entries(wPkg.dependencies ?? {})) {
+                    if (!(dep in rootDeps))
+                        rootDeps[dep] = ver;
+                }
+            }
+            for (const wPkgPath of workspacePkgPaths) {
+                const wNameRaw = await readFile(wPkgPath, 'utf8');
+                const wNamePkg = JSON.parse(wNameRaw);
+                if (wNamePkg.name) {
+                    delete rootDeps[wNamePkg.name];
+                }
+            }
+            pkg['dependencies'] = rootDeps;
+            delete pkg['workspaces'];
+            logWriteFile(packageJsonPath);
+            await writeFile(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+        }
+        await emptyDir(path.join(opts.rootDir, 'node_modules'), opts);
+        await removeFile(path.join(opts.rootDir, 'package-lock.json'), opts);
+        await removeFile(path.join(opts.rootDir, 'npm-shrinkwrap.json'), opts);
+        await runCommand('npm', ['install', '--omit=dev', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        await runCommand('npm', ['shrinkwrap', '--omit=dev', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        await runCommand('npm', ['pack'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+    }
+    finally {
+        logWriteFile(packageJsonPath);
+        if (!opts.dryRun) {
+            await restore(opts.rootDir);
+        }
+    }
+    await removeFile(path.join(opts.rootDir, 'package-lock.json'), opts);
+    await removeFile(path.join(opts.rootDir, 'npm-shrinkwrap.json'), opts);
+    await runCommand('npm', ['install', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+    if (await isPlugin(opts.rootDir))
+        await runCommand('npm', ['link', 'matterbridge', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+    await runBin('prettier', ['--log-level=silent', '--cache', '--cache-location', '.cache/.prettiercache', '--write', '.'], {
+        rootDir: opts.rootDir,
+        isWindows: opts.isWindows,
+        dryRun: opts.dryRun,
+        mode: 'build',
+        watch: false,
+    });
+    await runWorkspaceBuild({ rootDir: opts.rootDir, isWindows: opts.isWindows, dryRun: opts.dryRun, mode: 'build', watch: false });
+}

package/dist/publish.js

@@ -0,0 +1,78 @@
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { runBin, runWorkspaceBuild } from './build.js';
+import { backup, resolveWorkspacePackageJsonPaths, restore } from './cache.js';
+import { cleanOnly, emptyDir } from './clean.js';
+import { isPlugin } from './helpers.js';
+import { logDelete, logWriteFile } from './logger.js';
+import { runCommand } from './spawn.js';
+async function removeFile(filePath, opts) {
+    logDelete(filePath);
+    if (opts.dryRun)
+        return;
+    await rm(filePath, { force: true });
+}
+async function stripPackageJson(pkgPath, opts) {
+    logWriteFile(pkgPath);
+    if (opts.dryRun)
+        return;
+    const raw = await readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    delete pkg['devDependencies'];
+    delete pkg['scripts'];
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+}
+export async function runPublish(opts) {
+    const rootPkgPath = path.join(opts.rootDir, 'package.json');
+    const workspacePkgPaths = await resolveWorkspacePackageJsonPaths(opts.rootDir);
+    if (!opts.dryRun) {
+        await backup(opts.rootDir);
+    }
+    try {
+        await stripPackageJson(rootPkgPath, opts);
+        for (const wPkgPath of workspacePkgPaths) {
+            await stripPackageJson(wPkgPath, opts);
+        }
+        await cleanOnly({ rootDir: opts.rootDir, dryRun: opts.dryRun });
+        await runWorkspaceBuild({ rootDir: opts.rootDir, isWindows: opts.isWindows, dryRun: opts.dryRun, mode: 'production', watch: false });
+        await emptyDir(path.join(opts.rootDir, 'node_modules'), opts);
+        await removeFile(path.join(opts.rootDir, 'package-lock.json'), opts);
+        await removeFile(path.join(opts.rootDir, 'npm-shrinkwrap.json'), opts);
+        for (const wPkgPath of workspacePkgPaths) {
+            const wDir = path.dirname(wPkgPath);
+            await emptyDir(path.join(wDir, 'node_modules'), opts);
+            await removeFile(path.join(wDir, 'package-lock.json'), opts);
+            await removeFile(path.join(wDir, 'npm-shrinkwrap.json'), opts);
+        }
+        await runCommand('npm', ['install', '--omit=dev', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        await runCommand('npm', ['shrinkwrap', '--omit=dev', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        for (const wPkgPath of workspacePkgPaths) {
+            const wDir = path.dirname(wPkgPath);
+            await runCommand('npm', ['publish', '--dry-run'], { cwd: wDir, dryRun: opts.dryRun });
+        }
+        await runCommand('npm', ['publish', '--dry-run'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+    }
+    finally {
+        if (!opts.dryRun) {
+            await restore(opts.rootDir);
+        }
+        await removeFile(path.join(opts.rootDir, 'package-lock.json'), opts);
+        await removeFile(path.join(opts.rootDir, 'npm-shrinkwrap.json'), opts);
+        for (const wPkgPath of workspacePkgPaths) {
+            const wDir = path.dirname(wPkgPath);
+            await removeFile(path.join(wDir, 'package-lock.json'), opts);
+            await removeFile(path.join(wDir, 'npm-shrinkwrap.json'), opts);
+        }
+        await runCommand('npm', ['install', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        if (await isPlugin(opts.rootDir))
+            await runCommand('npm', ['link', 'matterbridge', '--no-fund', '--no-audit', '--silent'], { cwd: opts.rootDir, dryRun: opts.dryRun });
+        await runWorkspaceBuild({ rootDir: opts.rootDir, isWindows: opts.isWindows, dryRun: opts.dryRun, mode: 'build', watch: false });
+        await runBin('prettier', ['--log-level=silent', '--cache', '--cache-location', '.cache/.prettiercache', '--write', '.'], {
+            rootDir: opts.rootDir,
+            isWindows: opts.isWindows,
+            dryRun: opts.dryRun,
+            mode: 'build',
+            watch: false,
+        });
+    }
+}

package/dist/sort.js

@@ -0,0 +1,49 @@
+import { backup, packageJsonMap, restore } from './cache.js';
+export const PACKAGE_JSON_KEY_ORDER = [
+    'name',
+    'version',
+    'description',
+    'author',
+    'license',
+    'homepage',
+    'repository',
+    'bugs',
+    'funding',
+    'keywords',
+    'type',
+    'main',
+    'types',
+    'exports',
+    'workspaces',
+    'engines',
+    'bin',
+    'files',
+    'scripts',
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'peerDependenciesMeta',
+    'optionalDependencies',
+    'bundleDependencies',
+];
+export function sortPackageJson(pkg) {
+    const sorted = {};
+    for (const key of PACKAGE_JSON_KEY_ORDER) {
+        if (Object.prototype.hasOwnProperty.call(pkg, key)) {
+            sorted[key] = pkg[key];
+        }
+    }
+    for (const key of Object.keys(pkg)) {
+        if (!Object.prototype.hasOwnProperty.call(sorted, key)) {
+            sorted[key] = pkg[key];
+        }
+    }
+    return sorted;
+}
+export async function sortAll(rootDir) {
+    await backup(rootDir);
+    for (const [name, pkg] of packageJsonMap) {
+        packageJsonMap.set(name, sortPackageJson(pkg));
+    }
+    await restore(rootDir);
+}

package/dist/spawn.js

@@ -0,0 +1,27 @@
+import process from 'node:process';
+import spawn from 'cross-spawn';
+import { logCommand } from './logger.js';
+export class ExitError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export async function runCommand(command, args, options = {}) {
+    logCommand(options.label ?? command, options.displayArgs ?? args, options.cwd);
+    if (options.dryRun)
+        return;
+    const child = spawn(command, args, {
+        stdio: options.silent ? ['inherit', 'ignore', 'ignore'] : 'inherit',
+        env: { ...process.env, ...options.env },
+        cwd: options.cwd,
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.on('error', reject);
+        child.on('exit', (code) => resolve(code ?? 1));
+    });
+    if (exitCode !== 0) {
+        throw new ExitError(exitCode, `${options.label ?? command} failed with exit code ${exitCode}`);
+    }
+}

package/dist/update.js

@@ -0,0 +1,14 @@
+import { run as ncuRun } from 'npm-check-updates';
+import { parsePackageJson } from './helpers.js';
+export async function runUpdate(opts) {
+    if (opts.dryRun)
+        return;
+    const rootPkg = (await parsePackageJson(opts.rootDir));
+    const isWorkspace = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces.length > 0 : false;
+    if (isWorkspace) {
+        await ncuRun({ upgrade: true, workspaces: true, root: true, silent: true, cwd: opts.rootDir });
+    }
+    else {
+        await ncuRun({ upgrade: true, silent: true, cwd: opts.rootDir });
+    }
+}

package/dist/version.js

@@ -0,0 +1,159 @@
+import { execFileSync } from 'node:child_process';
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileExists } from './clean.js';
+import { parsePackageJson } from './helpers.js';
+import { logCommand, logWriteFile } from './logger.js';
+import { ExitError, runCommand } from './spawn.js';
+export function parseVersionTag(tag) {
+    const normalized = String(tag ?? '')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'dev' || normalized === 'edge' || normalized === 'git' || normalized === 'local' || normalized === 'next' || normalized === 'alpha' || normalized === 'beta') {
+        return normalized;
+    }
+    throw new ExitError(1, 'Missing or invalid --version tag (expected dev, edge, git, local, next, alpha, or beta).');
+}
+function formatYyyymmdd(date) {
+    const year = String(date.getFullYear());
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}${month}${day}`;
+}
+function shortSha7FromGit(cwd) {
+    logCommand('git', ['rev-parse', '--short=7', 'HEAD'], cwd);
+    const out = execFileSync('git', ['rev-parse', '--short=7', 'HEAD'], {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const sha = String(out).trim();
+    if (!/^[0-9a-f]{7}$/i.test(sha)) {
+        throw new Error(`Unexpected git short SHA output: ${JSON.stringify(sha)}`);
+    }
+    return sha.toLowerCase();
+}
+function getShortSha7(cwd) {
+    try {
+        return shortSha7FromGit(cwd);
+    }
+    catch (err) {
+        throw new ExitError(1, `Unable to determine git short SHA. (${err instanceof Error ? err.message : String(err)})`);
+    }
+}
+function extractBaseSemver(version) {
+    const trimmed = String(version ?? '').trim();
+    const match = /^([0-9]+\.[0-9]+\.[0-9]+)(?:-.+)?$/.exec(trimmed);
+    if (!match) {
+        throw new ExitError(1, `package.json version must start with plain x.y.z (got: ${JSON.stringify(trimmed)})`);
+    }
+    return match[1];
+}
+async function getWorkspacePackageJsonPaths(opts) {
+    const rootPkg = await parsePackageJson(opts.rootDir);
+    const workspacesConfig = rootPkg?.workspaces;
+    let patterns = [];
+    if (Array.isArray(workspacesConfig)) {
+        patterns = workspacesConfig.filter((p) => typeof p === 'string');
+    }
+    else if (workspacesConfig && typeof workspacesConfig === 'object' && Array.isArray(workspacesConfig.packages)) {
+        patterns = workspacesConfig.packages.filter((p) => typeof p === 'string');
+    }
+    if (patterns.length === 0) {
+        return [];
+    }
+    const hasGlobChars = (s) => /[*?\[]/.test(s);
+    const packageJsonPaths = [];
+    for (const pattern of patterns) {
+        const trimmed = pattern.trim();
+        if (!trimmed)
+            continue;
+        if (!hasGlobChars(trimmed)) {
+            const candidate = path.join(opts.rootDir, trimmed, 'package.json');
+            if (await fileExists(candidate))
+                packageJsonPaths.push(candidate);
+            continue;
+        }
+        if (trimmed.endsWith('/*') && trimmed.indexOf('*') === trimmed.length - 1 && !/[?\[]/.test(trimmed)) {
+            const baseRel = trimmed.slice(0, -2);
+            const baseAbs = path.join(opts.rootDir, baseRel);
+            let entries;
+            try {
+                entries = await readdir(baseAbs, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = path.join(baseAbs, entry.name, 'package.json');
+                if (await fileExists(candidate))
+                    packageJsonPaths.push(candidate);
+            }
+            continue;
+        }
+        throw new ExitError(1, `Unsupported workspaces pattern in root package.json: ${JSON.stringify(trimmed)} (use explicit paths or a simple 'dir/*' glob)`);
+    }
+    return Array.from(new Set(packageJsonPaths));
+}
+export async function updateRootVersion(tag, opts) {
+    const pkg = await parsePackageJson(opts.rootDir);
+    const currentVersion = pkg.version;
+    const baseVersion = extractBaseSemver(currentVersion);
+    const nextVersion = tag ? `${baseVersion}-${tag}-${formatYyyymmdd(new Date())}-${getShortSha7(opts.rootDir)}` : baseVersion;
+    const workspacesConfig = pkg?.workspaces;
+    const hasWorkspaces = Array.isArray(workspacesConfig) || (workspacesConfig && typeof workspacesConfig === 'object' && Array.isArray(workspacesConfig.packages));
+    const args = hasWorkspaces
+        ? ['version', nextVersion, '--workspaces', '--include-workspace-root', '--no-workspaces-update', '--no-git-tag-version', '--ignore-scripts', '--allow-same-version']
+        : ['version', nextVersion, '--no-git-tag-version', '--ignore-scripts', '--allow-same-version'];
+    await runCommand('npm', args, { cwd: opts.rootDir, dryRun: opts.dryRun, silent: true });
+    return nextVersion;
+}
+export async function updateWorkspaceDependencyVersions(targetVersion, opts) {
+    const packageJsonPaths = await getWorkspacePackageJsonPaths(opts);
+    if (packageJsonPaths.length === 0)
+        return;
+    const workspacePkgs = await Promise.all(packageJsonPaths.map(async (p) => {
+        const raw = await readFile(p, 'utf8');
+        const pkg = JSON.parse(raw);
+        const name = typeof pkg?.name === 'string' ? pkg.name : null;
+        if (!name) {
+            throw new ExitError(1, `Workspace package.json missing name: ${p}`);
+        }
+        return { path: p, name };
+    }));
+    const workspaceNames = new Set(workspacePkgs.map((p) => p.name));
+    const sections = ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies'];
+    const rootPackageJsonPath = path.join(opts.rootDir, 'package.json');
+    const rootParsed = (await parsePackageJson(opts.rootDir));
+    const rootName = typeof rootParsed.name === 'string' ? rootParsed.name : '';
+    const pkgsToUpdate = [...workspacePkgs, { path: rootPackageJsonPath, name: rootName }];
+    await Promise.all(pkgsToUpdate.map(async ({ path: packageJsonPath, name: selfName }) => {
+        const raw = await readFile(packageJsonPath, 'utf8');
+        const pkg = JSON.parse(raw);
+        let changed = false;
+        for (const section of sections) {
+            const deps = pkg?.[section];
+            if (!deps || typeof deps !== 'object')
+                continue;
+            for (const depName of Object.keys(deps)) {
+                if (!workspaceNames.has(depName))
+                    continue;
+                if (depName === selfName)
+                    continue;
+                const nextRange = targetVersion;
+                if (deps[depName] !== nextRange) {
+                    deps[depName] = nextRange;
+                    changed = true;
+                }
+            }
+        }
+        if (changed) {
+            logWriteFile(packageJsonPath);
+            if (opts.dryRun)
+                return;
+            await writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+        }
+    }));
+}