@emeryld/manager 0.2.1 → 0.2.3

package/dist/release.js

@@ -0,0 +1,292 @@
+// src/release.js
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { stageCommitPush } from './git.js';
+import { askLine, promptSingleKey, promptYesNoAll } from './prompts.js';
+import { bumpVersion, isSemver } from './semver.js';
+import { colors, formatPkgName, logGlobal, logPkg } from './utils/log.js';
+import { run } from './utils/run.js';
+const bumpMap = {
+    '1': 'patch',
+    '2': 'minor',
+    '3': 'major',
+    // mapped from pre-release submenu later, but keep named keys for nonInteractive
+    patch: 'patch',
+    minor: 'minor',
+    major: 'major',
+    prepatch: 'prepatch',
+    preminor: 'preminor',
+    premajor: 'premajor',
+    prerelease: 'prerelease',
+};
+function preBumpFromChoice(choice) {
+    switch (choice) {
+        case '1':
+            return 'prepatch';
+        case '2':
+            return 'preminor';
+        case '3':
+            return 'premajor';
+        case '4':
+            return 'prerelease';
+        default:
+            return undefined;
+    }
+}
+async function writePackageJson(pkgPath, json) {
+    await writeFile(pkgPath, `${JSON.stringify(json, null, 2)}\n`);
+}
+async function refreshPackagesFromDisk(pkgs) {
+    await Promise.all(pkgs.map(async (pkg) => {
+        const raw = await readFile(pkg.packageJsonPath, 'utf8');
+        const json = JSON.parse(raw);
+        pkg.json = json;
+        pkg.version = json.version ?? pkg.version;
+        if (json.name)
+            pkg.name = json.name;
+    }));
+}
+async function ensureNpmAuth() {
+    try {
+        await run('pnpm', ['whoami']);
+    }
+    catch {
+        throw new Error('Not authenticated to registry. Run "pnpm login" and retry.');
+    }
+}
+function ensureNotPrivate(targets) {
+    const privates = targets.filter((p) => p.json?.private);
+    if (privates.length) {
+        const names = privates.map((p) => p.name).join(', ');
+        throw new Error(`Refusing to publish private packages: ${names}`);
+    }
+}
+async function publishPackage(pkg, opts = {}) {
+    const args = ['publish', '--access', 'public'];
+    let tag = opts.tag;
+    if (!tag) {
+        tag = inferTagFromVersion(pkg.version || '');
+    }
+    if (tag)
+        args.push('--tag', tag);
+    if (opts.dryRun)
+        args.push('--dry-run');
+    if (opts.provenance)
+        args.push('--provenance');
+    logPkg(pkg, `Publishing ${pkg.name}…`, colors.green);
+    try {
+        await run('pnpm', args, { cwd: pkg.path });
+        logPkg(pkg, `${pkg.name} published.`, colors.green);
+        const tagName = `${pkg.name}@${pkg.version}`;
+        const tagMessage = opts.releaseNotes
+            ? `release ${pkg.version}\n\n${opts.releaseNotes}`
+            : `release ${pkg.version}`;
+        await run('git', ['tag', '-a', tagName, '-m', tagMessage]);
+        await run('git', ['push', 'origin', tagName]);
+    }
+    catch (err) {
+        console.error(colors.red(`Publish failed for ${pkg.name}.`));
+        console.error(colors.dim('To revert the version commit: git revert HEAD && git push'));
+        throw err;
+    }
+}
+async function applyVersionStrategy(strategy, targetPkg, packages, opts = {}) {
+    if (strategy.mode === 'noop') {
+        console.log('\nSkipping version bump (no version change selected).');
+        return { changedPaths: [], commitMessage: '' };
+    }
+    if (strategy.mode === 'sync') {
+        console.log();
+        logGlobal('Syncing all package versions…', colors.cyan);
+        await run('pnpm', ['sync', strategy.version]);
+        packages.forEach((pkg) => {
+            pkg.version = strategy.version;
+            pkg.json.version = strategy.version;
+        });
+        return {
+            changedPaths: [
+                'package.json',
+                ...packages.map((pkg) => path.relative(process.cwd(), pkg.packageJsonPath)),
+            ],
+            commitMessage: `chore(release): sync ${strategy.version}`,
+        };
+    }
+    // mode === 'bump'
+    const nextVersion = bumpVersion(targetPkg.version, strategy.bumpType, strategy.preid);
+    console.log(`\nUpdating ${formatPkgName(targetPkg)} version to ${colors.green(nextVersion)}`);
+    targetPkg.json.version = nextVersion;
+    targetPkg.version = nextVersion;
+    await writePackageJson(targetPkg.packageJsonPath, targetPkg.json);
+    return {
+        changedPaths: [path.relative(process.cwd(), targetPkg.packageJsonPath)],
+        commitMessage: opts?.releaseNotes
+            ? `chore(release): ${targetPkg.name}@${nextVersion} - ${opts.releaseNotes}`
+            : `chore(release): ${targetPkg.name}@${nextVersion}`,
+    };
+}
+function strategyFromOptions(targetPkg, selection, opts) {
+    if (!opts?.nonInteractive)
+        return undefined;
+    if (opts.syncVersion) {
+        if (!isSemver(opts.syncVersion))
+            throw new Error(`Invalid version "${opts.syncVersion}"`);
+        return { mode: 'sync', version: opts.syncVersion };
+    }
+    if (opts.bumpType)
+        return { mode: 'bump', bumpType: opts.bumpType, preid: opts.preid };
+    return { mode: 'noop' };
+}
+function inferTagFromVersion(version) {
+    const match = version.match(/-([0-9A-Za-z-]+)(?:\.\d+)?$/);
+    if (!match)
+        return undefined;
+    const preid = match[1].toLowerCase();
+    if (['alpha', 'beta', 'rc'].includes(preid))
+        return preid;
+    return 'next';
+}
+function inferPreidFromVersion(version) {
+    const match = version.match(/-([0-9A-Za-z-]+)/);
+    return match?.[1]?.toLowerCase();
+}
+export async function promptVersionStrategy(targetPkg, selection, opts) {
+    const viaOpts = strategyFromOptions(targetPkg, selection, opts);
+    if (viaOpts)
+        return viaOpts;
+    console.log('\nCurrent package versions:');
+    for (const pkg of selection) {
+        const marker = selection.length === 1 && pkg.dirName === targetPkg.dirName ? '*' : '•';
+        console.log(` ${marker} ${formatPkgName(pkg)} ${pkg.dirName} ${colors.yellow(pkg.version)}`);
+    }
+    console.log('\nSelect version strategy:');
+    console.log(' 1) Patch');
+    console.log(' 2) Minor');
+    console.log(' 3) Major');
+    console.log(' 4) Pre-release (alpha / beta / rc)');
+    console.log(' 5) Sync packages');
+    console.log(' 6) No version change');
+    const choice = await promptSingleKey('Choice: ', (key) => {
+        if (['1', '2', '3', '4', '5', '6'].includes(key))
+            return key;
+        return undefined;
+    });
+    console.log(choice);
+    // Sync
+    if (choice === '5') {
+        const desired = await askLine('Enter unified version: ');
+        if (!isSemver(desired))
+            throw new Error(`Invalid version "${desired}"`);
+        return { mode: 'sync', version: desired };
+    }
+    // No version change
+    if (choice === '6') {
+        const ans = await promptYesNoAll('Publish without changing any versions?');
+        if (ans === 'no') {
+            console.log('Aborting.');
+            process.exit(0);
+        }
+        return { mode: 'noop' };
+    }
+    // Pre-release submenu
+    let preid;
+    let bumpType;
+    if (choice === '4') {
+        const currentVersion = targetPkg.version || '?';
+        const defaultPreid = inferPreidFromVersion(currentVersion) || 'alpha';
+        const preview = (type) => {
+            try {
+                return bumpVersion(currentVersion, type, defaultPreid);
+            }
+            catch {
+                return '?';
+            }
+        };
+        console.log('\nSelect pre-release bump type:');
+        console.log(` 1) prepatch   (${currentVersion} -> ${preview('prepatch')})`);
+        console.log(` 2) preminor   (${currentVersion} -> ${preview('preminor')})`);
+        console.log(` 3) premajor   (${currentVersion} -> ${preview('premajor')})`);
+        console.log(` 4) prerelease (${currentVersion} -> ${preview('prerelease')})`);
+        const preChoice = await promptSingleKey('Choice: ', (key) => {
+            if (['1', '2', '3', '4'].includes(key))
+                return key;
+            return undefined;
+        });
+        console.log(preChoice);
+        bumpType = preBumpFromChoice(preChoice);
+        if (!bumpType)
+            throw new Error('Invalid pre-release selection.');
+        const rawPreid = await askLine('Pre-release identifier (e.g. alpha, beta, rc) [alpha]: ');
+        preid = (rawPreid.trim() || 'alpha').toLowerCase();
+    }
+    else {
+        // Regular patch / minor / major
+        bumpType = bumpMap[choice];
+    }
+    if (!bumpType)
+        throw new Error('Invalid selection.');
+    // Preview what will happen
+    if (selection.length === 1) {
+        const proposed = bumpVersion(targetPkg.version, bumpType, preid);
+        console.log(`\nTarget package: ${formatPkgName(targetPkg)} -> ${colors.green(proposed)}`);
+        const others = selection.filter((pkg) => pkg.dirName !== targetPkg.dirName);
+        if (others.length) {
+            console.log('Other packages:');
+            others.forEach((pkg) => {
+                console.log(` - ${formatPkgName(pkg)} ${colors.yellow(pkg.version)}`);
+            });
+        }
+    }
+    else {
+        console.log(`\nApplying a ${bumpType}${preid ? ` (${preid})` : ''} bump to all selected packages:`);
+        selection.forEach((pkg) => {
+            const nextVersion = bumpVersion(pkg.version, bumpType, preid);
+            const arrow = nextVersion === pkg.version ? '─' : '→';
+            console.log(` - ${formatPkgName(pkg)} ${colors.yellow(pkg.version)} ${arrow} ${colors.green(nextVersion)}`);
+        });
+    }
+    const confirm = await promptYesNoAll(selection.length === 1
+        ? `Apply ${bumpType}${preid ? ` (${preid})` : ''} bump to ${targetPkg.name}?`
+        : `Apply ${bumpType}${preid ? ` (${preid})` : ''} bump to all selected packages?`);
+    if (confirm === 'no') {
+        console.log('Aborting.');
+        process.exit(0);
+    }
+    return { mode: 'bump', bumpType, preid };
+}
+export async function releaseSingle(targetPkg, packages, opts = {}) {
+    await ensureNpmAuth();
+    await refreshPackagesFromDisk([targetPkg]);
+    ensureNotPrivate([targetPkg]);
+    console.log(`\n${formatPkgName(targetPkg)} ${colors.dim('(single release)')}`);
+    const strategy = await promptVersionStrategy(targetPkg, [targetPkg], opts);
+    const { changedPaths, commitMessage } = await applyVersionStrategy(strategy, targetPkg, packages, opts);
+    await stageCommitPush(changedPaths, commitMessage);
+    await publishPackage(targetPkg, opts);
+}
+export async function releaseMultiple(targets, packages, opts = {}) {
+    await ensureNpmAuth();
+    await refreshPackagesFromDisk(targets);
+    ensureNotPrivate(targets);
+    console.log(`\n🚀 ${'*'} Publishing all selected packages`);
+    const strategy = await promptVersionStrategy(targets[0], targets, opts);
+    let changedPaths = [];
+    let commitMessage = '';
+    if (strategy.mode === 'sync') {
+        const result = await applyVersionStrategy(strategy, targets[0], packages, opts);
+        changedPaths = result.changedPaths;
+        commitMessage = result.commitMessage;
+    }
+    else if (strategy.mode === 'bump') {
+        for (const pkg of targets) {
+            const result = await applyVersionStrategy(strategy, pkg, packages, opts);
+            changedPaths.push(...result.changedPaths);
+        }
+        commitMessage = `chore(release): ${targets.map((p) => `${p.name}@${p.version}`).join(', ')}`;
+    }
+    if (changedPaths.length || commitMessage) {
+        await stageCommitPush(changedPaths, commitMessage || `chore(release): publish ${targets.length} package(s)`);
+    }
+    for (const pkg of targets) {
+        await publishPackage(pkg, opts);
+    }
+}

package/dist/semver.js

@@ -0,0 +1,17 @@
+// src/semver.js
+import { inc, valid, } from 'semver';
+export function bumpVersion(version, type, preid) {
+    let next;
+    if (preid) {
+        next = inc(version, type, preid);
+    }
+    else {
+        next = inc(version, type);
+    }
+    if (!next)
+        throw new Error(`Cannot bump invalid version "${version}" by "${type}"`);
+    return next;
+}
+export function isSemver(version) {
+    return Boolean(valid(version));
+}

package/dist/utils/colors.js

@@ -0,0 +1,11 @@
+// src/utils/colors.js
+const ansi = (code) => (text) => `\x1b[${code}m${text}\x1b[0m`;
+export const colors = {
+    cyan: ansi(36),
+    green: ansi(32),
+    yellow: ansi(33),
+    magenta: ansi(35),
+    red: ansi(31),
+    bold: ansi(1),
+    dim: ansi(2),
+};

package/dist/utils/log.js

@@ -0,0 +1,19 @@
+// src/utils/log.js
+import { colors } from './colors.js';
+export const defaultPackageColor = 'cyan';
+export const globalEmoji = '🚀';
+export const formatPkgName = (pkg) => {
+    const primary = pkg.substitute;
+    const displayName = pkg.name ?? pkg.dirName;
+    const fileLabel = pkg.dirName;
+    const colorizer = colors[pkg.color ?? defaultPackageColor];
+    return `${colorizer(colors.bold(primary))} ${colors.dim(`(${displayName}) [${fileLabel}]`)}`;
+};
+export const logPkg = (pkg, message, colorizer = colors.cyan) => {
+    const label = colors[pkg.color ?? defaultPackageColor](pkg.substitute);
+    console.log(`${label} ${colorizer(message)}`);
+};
+export const logGlobal = (message, colorizer = colors.magenta) => {
+    console.log(`${globalEmoji} ${colorizer(message)}`);
+};
+export { colors };

package/dist/utils/run.js

@@ -0,0 +1,21 @@
+// src/utils/run.js
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+export const rootDir = path.resolve(path.dirname(__filename), '..', '..');
+export function run(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: rootDir,
+            stdio: 'inherit',
+            ...options,
+        });
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Command "${command} ${args.join(' ')}" exited with ${code}`));
+        });
+    });
+}

package/dist/workspace.js

@@ -0,0 +1,246 @@
+// src/workspace.js
+import { spawnSync } from 'node:child_process';
+import { run, rootDir } from './utils/run.js';
+import { logGlobal, logPkg, colors } from './utils/log.js';
+import { collectGitStatus, gitAdd, gitCommit } from './git.js';
+import { askLine, promptSingleKey } from './prompts.js';
+const dependencyFiles = new Set([
+    'package.json',
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'npm-shrinkwrap.json',
+    'pnpm-workspace.yaml',
+]);
+function extractPathFromStatus(line) {
+    const match = line.match(/^[AMDR\? ][\S\?]\s+(.*)$/);
+    if (!match)
+        return undefined;
+    const rawPath = match[1].trim().replace(/"/g, '');
+    const normalized = rawPath.includes(' -> ')
+        ? rawPath.split(' -> ').pop()
+        : rawPath;
+    return normalized;
+}
+function dependencyPathsFromStatus(status) {
+    return status
+        .map(extractPathFromStatus)
+        .filter((p) => Boolean(p && dependencyFiles.has(p.split('/').pop() ?? '')));
+}
+function formatPkgLabel(pkg) {
+    return pkg.substitute ?? pkg.name ?? pkg.dirName;
+}
+function logDependencyChanges(paths, targets) {
+    if (paths.length === 0)
+        return;
+    const byDir = new Map(targets.map((t) => [t.dirName, formatPkgLabel(t)]));
+    logGlobal('Dependency file changes detected:', colors.cyan);
+    paths.forEach((p) => {
+        const parts = p.split('/');
+        const file = parts[parts.length - 1];
+        const pkgIndex = parts.indexOf('packages');
+        if (pkgIndex !== -1 && parts[pkgIndex + 1]) {
+            const dir = parts[pkgIndex + 1];
+            const fileLabel = parts.slice(pkgIndex + 2).join('/') || 'package.json';
+            console.log(`  • ${colors.dim(`${byDir.get(dir) ?? dir} (${fileLabel})`)}`);
+            return;
+        }
+        if (file === 'pnpm-lock.yaml' ||
+            file === 'package-lock.json' ||
+            file === 'npm-shrinkwrap.json') {
+            console.log(`  • ${colors.dim(`workspace lockfile (${file})`)}`);
+            return;
+        }
+        if (file === 'pnpm-workspace.yaml') {
+            console.log(`  • ${colors.dim('workspace pnpm-workspace.yaml')}`);
+            return;
+        }
+        if (file === 'package.json') {
+            console.log(`  • ${colors.dim('workspace package.json')}`);
+            return;
+        }
+        console.log(`  • ${colors.dim(p)}`);
+    });
+}
+function readDiff(path) {
+    const res = spawnSync('git', ['diff', '--unified=0', '--', path], {
+        cwd: rootDir,
+        encoding: 'utf8',
+    });
+    if (typeof res.stdout === 'string')
+        return res.stdout;
+    return '';
+}
+function parseVersionChanges(path, label) {
+    const diff = readDiff(path);
+    if (!diff)
+        return [];
+    const changes = new Map();
+    const lineRe = /^[\-\+]\s+"([^"]+)":\s*"([^"]+)"/;
+    diff.split('\n').forEach((line) => {
+        if (line.startsWith('+++') || line.startsWith('---'))
+            return;
+        const match = line.match(lineRe);
+        if (!match)
+            return;
+        const [, dep, version] = match;
+        const entry = changes.get(dep) ?? {};
+        if (line.startsWith('-'))
+            entry.from = version;
+        if (line.startsWith('+'))
+            entry.to = version;
+        changes.set(dep, entry);
+    });
+    return [...changes.entries()]
+        .filter(([, v]) => v.from && v.to && v.from !== v.to)
+        .map(([dep, v]) => ({
+        dep,
+        from: v.from,
+        to: v.to,
+        label,
+    }));
+}
+function summarizeVersionChanges(paths, targets) {
+    const byDir = new Map(targets.map((t) => [t.dirName, formatPkgLabel(t)]));
+    const changes = [];
+    paths
+        .filter((p) => p.endsWith('package.json'))
+        .forEach((p) => {
+        const parts = p.split('/');
+        const pkgIndex = parts.indexOf('packages');
+        const label = pkgIndex !== -1 && parts[pkgIndex + 1]
+            ? (byDir.get(parts[pkgIndex + 1]) ?? parts[pkgIndex + 1])
+            : 'workspace';
+        changes.push(...parseVersionChanges(p, label));
+    });
+    if (changes.length === 0)
+        return '';
+    const grouped = new Map();
+    changes.forEach((c) => {
+        const list = grouped.get(c.label) ?? [];
+        list.push(c);
+        grouped.set(c.label, list);
+    });
+    const summaries = [];
+    grouped.forEach((list, label) => {
+        const slice = list.slice(0, 3).map((c) => `${c.dep} ${c.from}→${c.to}`);
+        const extra = list.length > slice.length ? ` (+${list.length - slice.length} more)` : '';
+        summaries.push(`${label}: ${slice.join(', ')}${extra}`);
+    });
+    return summaries.join('; ');
+}
+function buildUpdateCommitMessage(paths, targets) {
+    const changeSummary = summarizeVersionChanges(paths, targets);
+    if (changeSummary)
+        return `chore(deps): ${changeSummary}`;
+    const labels = new Set();
+    const byDir = new Map(targets.map((t) => [t.dirName, formatPkgLabel(t)]));
+    paths.forEach((p) => {
+        const parts = p.split('/');
+        const pkgIndex = parts.indexOf('packages');
+        if (pkgIndex !== -1 && parts[pkgIndex + 1]) {
+            const dir = parts[pkgIndex + 1];
+            labels.add(byDir.get(dir) ?? dir);
+            return;
+        }
+        if (parts[parts.length - 1] === 'package.json') {
+            labels.add('workspace deps');
+        }
+    });
+    if (labels.size === 0 && targets.length === 1) {
+        labels.add(formatPkgLabel(targets[0]));
+    }
+    const labelList = [...labels];
+    if (labelList.length === 0)
+        return 'chore(deps): update dependencies';
+    if (labelList.length === 1)
+        return `chore(deps): update ${labelList[0]}`;
+    return `chore(deps): update ${labelList.join(', ')}`;
+}
+async function promptCommitMessage(proposed) {
+    const confirm = await promptSingleKey(`Use commit message "${proposed}"? (y/n): `, (key) => {
+        if (key === 'y')
+            return 'yes';
+        if (key === 'n')
+            return 'no';
+        return undefined;
+    });
+    if (confirm === 'yes')
+        return proposed;
+    let custom = '';
+    while (!custom.trim()) {
+        // eslint-disable-next-line no-await-in-loop
+        custom = await askLine('Enter commit message: ');
+        if (!custom.trim())
+            console.log(colors.red('Commit message cannot be empty.'));
+    }
+    return custom.trim();
+}
+export async function runCleanInstall() {
+    logGlobal('Cleaning workspace…', colors.cyan);
+    await run('pnpm', ['run', 'clean']);
+    logGlobal('Reinstalling dependencies…', colors.cyan);
+    await run('pnpm', ['install']);
+}
+export async function updateDependencies(targets) {
+    const preStatus = await collectGitStatus();
+    if (targets.length === 1) {
+        const filterArg = targets[0].name ?? `./packages/${targets[0].dirName}`;
+        logPkg(targets[0], `Updating dependencies…`);
+        await run('pnpm', ['-r', '--filter', filterArg, 'update']);
+    }
+    else {
+        logGlobal('Updating dependencies across the workspace…', colors.cyan);
+        await run('pnpm', ['-r', 'update']);
+    }
+    const postStatus = await collectGitStatus();
+    const depPaths = dependencyPathsFromStatus(postStatus);
+    const uniqueDepPaths = [...new Set(depPaths)];
+    if (uniqueDepPaths.length === 0) {
+        logGlobal('No dependency file changes detected; skipping commit.', colors.dim);
+        return;
+    }
+    if (preStatus.length) {
+        logGlobal('Working tree had changes before update; will only stage dependency files for the commit.', colors.yellow);
+    }
+    logDependencyChanges(uniqueDepPaths, targets);
+    const proposed = buildUpdateCommitMessage(uniqueDepPaths, targets);
+    const message = await promptCommitMessage(proposed);
+    logGlobal('Staging dependency changes…', colors.cyan);
+    await gitAdd(uniqueDepPaths);
+    logGlobal('Creating commit…', colors.cyan);
+    await gitCommit(message);
+    logGlobal(`Commit created: ${message}`, colors.green);
+    logGlobal('Pushing to origin…', colors.cyan);
+    await run('git', ['push']);
+    logGlobal('Push complete.', colors.green);
+}
+export async function typecheckAll() {
+    logGlobal('Running typecheck for all packages…', colors.cyan);
+    await run('pnpm', ['typecheck']);
+}
+export async function typecheckSingle(pkg) {
+    const filterArg = pkg.name ?? `./packages/${pkg.dirName}`;
+    logPkg(pkg, `Running typecheck…`);
+    await run('pnpm', ['run', '--filter', filterArg, 'typecheck']);
+}
+export async function buildAll() {
+    logGlobal('Running build for all packages…', colors.cyan);
+    await run('pnpm', ['build']);
+}
+export async function buildSingle(pkg) {
+    const filterArg = pkg.name ?? `./packages/${pkg.dirName}`;
+    logPkg(pkg, `Running build…`);
+    await run('pnpm', ['run', '--filter', filterArg, 'build']);
+}
+export async function buildPackageLocally(pkg) {
+    logPkg(pkg, 'Building local dist before publish…');
+    await run('pnpm', ['run', 'build'], { cwd: pkg.path });
+}
+export async function testAll() {
+    logGlobal('Running tests for all packages…', colors.cyan);
+    await run('pnpm', ['test']);
+}
+export async function testSingle(pkg) {
+    logPkg(pkg, `Running tests…`);
+    await run('pnpm', ['test', '--', `packages/${pkg.dirName}`]);
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@emeryld/manager",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "manager-cli": "bin/manager-cli.js"
+    "manager-cli": "dist/manager-cli.js"
   },
   "files": [
-    "src",
+    "dist",
     "bin",
     "tsconfig.base.json",
     "tsconfig.json"
@@ -39,7 +39,7 @@
     "swc": false
   },
   "scripts": {
-    "build": "tsc -p tsconfig.base.json",
+    "build": "tsc -p tsconfig.base.json && node scripts/copy-manager-cli.mjs",
     "typecheck": "tsc -p tsconfig.base.json --noEmit",
     "test": "cross-env TS_NODE_PROJECT=tsconfig.test.json node --loader ts-node/esm test/helper-cli.test.ts"
   }