@emeryld/manager 0.6.2 → 0.6.4

package/dist/menu.js

@@ -1,13 +1,14 @@
 // src/menu.js
 import path from 'node:path';
 import { colors, globalEmoji } from './utils/log.js';
-import { updateDependencies, testAll, testSingle, buildAll, buildSingle, } from './workspace.js';
+import { updateDependencies, testAll, testSingle, buildAll, buildSingle, cleanPackages, rebuildPackages, } from './workspace.js';
 import { releaseMultiple, releaseSingle } from './release.js';
 import { getOrderedPackages } from './packages.js';
 import { runHelperCli } from './helper-cli.js';
 import { ensureWorkingTreeCommitted } from './preflight.js';
 import { openDockerHelper } from './docker.js';
 import { run } from './utils/run.js';
+import { makeBaseScriptEntries, getPackageMarker } from './menu/script-helpers.js';
 function makeManagerStepEntries(targets, packages, state, options) {
     const includeBack = options?.includeBack ?? true;
     return [
@@ -20,6 +21,24 @@ function makeManagerStepEntries(targets, packages, state, options) {
                 state.lastStep = 'update';
             },
         },
+        {
+            name: 'clean',
+            emoji: '🧹',
+            description: 'Remove node_modules, dist, and caches',
+            handler: async () => {
+                await cleanPackages(targets);
+                state.lastStep = 'clean';
+            },
+        },
+        {
+            name: 'rebuild',
+            emoji: '🔁',
+            description: 'Clean then build',
+            handler: async () => {
+                await rebuildPackages(targets);
+                state.lastStep = 'rebuild';
+            },
+        },
         {
             name: 'test',
             emoji: '🧪',
@@ -93,25 +112,32 @@ function makeManagerStepEntries(targets, packages, state, options) {
             : []),
     ];
 }
-function makePackageScriptEntries(pkg) {
-    const scripts = pkg.json?.scripts ?? {};
-    const entries = [];
+function makeDockerEntry(pkg) {
     if (pkg.dockerfilePath) {
         const dockerLabel = path
             .relative(process.cwd(), pkg.dockerfilePath)
             .replace(/\\/g, '/');
-        entries.push({
+        return {
             name: `Dockerfile (${dockerLabel})`,
             emoji: '🐳',
             description: 'manager -> opens the docker cli',
             handler: async () => {
                 await openDockerHelper(pkg);
             },
-        });
+        };
     }
+    return undefined;
+}
+function makePackageScriptEntries(pkg) {
+    const scripts = pkg.json?.scripts ?? {};
+    const baseEntries = makeBaseScriptEntries(pkg);
+    const baseNames = new Set(baseEntries.map((entry) => entry.name));
+    const entries = [];
     Object.entries(scripts)
         .sort(([a], [b]) => a.localeCompare(b))
         .forEach(([name, command]) => {
+        if (baseNames.has(name))
+            return;
         entries.push({
             name,
             emoji: '▶️',
@@ -121,23 +147,31 @@ function makePackageScriptEntries(pkg) {
             },
         });
     });
-    return entries;
+    return [...baseEntries, ...entries];
 }
 export function buildPackageSelectionMenu(packages, onStepComplete) {
     const ordered = getOrderedPackages(packages);
-    const entries = ordered.map((pkg) => ({
-        name: pkg.name ?? pkg.substitute ?? pkg.dirName,
-        emoji: colors[pkg.color]('●'),
-        description: pkg.relativeDir ?? pkg.dirName,
-        handler: async () => {
-            const step = await runStepLoop([pkg], packages);
-            onStepComplete?.(step);
-        },
-    }));
+    const entries = ordered.map((pkg) => {
+        const marker = getPackageMarker(pkg);
+        const pkgColor = pkg.color ?? 'cyan';
+        const descriptionMeta = pkg.relativeDir ?? pkg.dirName;
+        const markerHint = marker.label ? ` · ${marker.label}` : '';
+        return {
+            name: pkg.name ?? pkg.substitute ?? pkg.dirName,
+            emoji: marker.colorize('●'),
+            description: `${descriptionMeta}${colors.dim(markerHint)}`,
+            color: pkgColor,
+            handler: async () => {
+                const step = await runStepLoop([pkg], packages);
+                onStepComplete?.(step);
+            },
+        };
+    });
     if (ordered.length === 0)
         return entries;
     entries.push({
         name: 'All packages',
+        color: 'gray',
         emoji: globalEmoji,
         description: 'Select all packages',
         handler: async () => {
@@ -154,10 +188,12 @@ export async function runStepLoop(targets, packages) {
     // Single package: show combined menu (manager actions + package.json scripts)
     if (targets.length === 1) {
         const pkg = targets[0];
+        const dockerEntry = makeDockerEntry(pkg);
         // eslint-disable-next-line no-constant-condition
         while (true) {
             const scriptEntries = makePackageScriptEntries(pkg);
             const entries = [
+                ...(dockerEntry ? [dockerEntry] : []),
                 {
                     name: 'manager actions',
                     emoji: globalEmoji,
@@ -170,9 +206,8 @@ export async function runStepLoop(targets, packages) {
                             {
                                 name: 'back',
                                 emoji: '↩️',
-                                description: 'Return to package scripts',
+                                description: 'Return to package menu',
                                 handler: () => {
-                                    // no state change; just exit to the package scripts menu
                                     state.lastStep = undefined;
                                 },
                             },
@@ -184,7 +219,31 @@ export async function runStepLoop(targets, packages) {
                         });
                     },
                 },
-                ...scriptEntries,
+                {
+                    name: 'package scripts',
+                    emoji: '📜',
+                    description: 'Run package.json scripts',
+                    handler: async () => {
+                        if (scriptEntries.length === 0) {
+                            console.log(colors.yellow(`No package.json scripts found for ${pkg.name}.`));
+                            return;
+                        }
+                        const scriptsMenu = [
+                            ...scriptEntries,
+                            {
+                                name: 'back',
+                                emoji: '↩️',
+                                description: 'Return to package menu',
+                                handler: () => { },
+                            },
+                        ];
+                        await runHelperCli({
+                            title: `${pkg.name} scripts`,
+                            scripts: scriptsMenu,
+                            argv: [],
+                        });
+                    },
+                },
                 {
                     name: 'back',
                     emoji: '↩️',

package/dist/packages.js

@@ -1,161 +1,17 @@
 // src/packages.js
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { readdir, readFile, stat } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
+import { colorFromSeed, deriveSubstitute, inferManifestFromWorkspace, loadWorkspaceManifest, mergeManifestEntries, normalizeManifestPath, } from './packages/manifest-utils.js';
 const rootDir = process.cwd();
-const ignoredDirs = new Set([
-    'node_modules',
-    '.git',
-    '.turbo',
-    '.next',
-    'dist',
-    'build',
-    '.cache',
-    'coverage',
-]);
-const colorPalette = ['cyan', 'green', 'yellow', 'magenta', 'red'];
 let manifestState;
-function manifestFilePath() {
-    return path.join(rootDir, 'scripts', 'packages.mjs');
-}
-function isManifestMissing(error) {
-    if (typeof error !== 'object' || error === null)
-        return false;
-    const code = error.code;
-    return code === 'ERR_MODULE_NOT_FOUND' || code === 'ENOENT';
-}
-function normalizeManifestPath(value) {
-    const absolute = path.resolve(rootDir, value || '');
-    let relative = path.relative(rootDir, absolute);
-    if (!relative)
-        return '.';
-    relative = relative.replace(/\\/g, '/');
-    return relative.replace(/^(?:\.\/)+/, '');
-}
-function colorFromSeed(seed) {
-    const normalized = `${seed}`.trim() || 'package';
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        hash = (hash * 31 + normalized.charCodeAt(i)) >>> 0;
-    }
-    return colorPalette[hash % colorPalette.length];
-}
-function deriveSubstitute(name) {
-    const trimmed = (name || '').trim();
-    if (!trimmed)
-        return '';
-    const segments = trimmed.split(/[@\/\-]/).filter(Boolean);
-    const transformed = segments
-        .map((segment) => segment)
-        .filter(Boolean)
-        .join(' ');
-    return transformed || trimmed;
-}
-async function findPackageJsonFiles(baseDir) {
-    const results = new Set();
-    const queue = [baseDir];
-    while (queue.length) {
-        const current = queue.shift();
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (entry.isFile() && entry.name === 'package.json') {
-                results.add(path.join(current, entry.name));
-            }
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.isSymbolicLink())
-                continue;
-            if (ignoredDirs.has(entry.name))
-                continue;
-            queue.push(path.join(current, entry.name));
-        }
-    }
-    return [...results].sort();
-}
-async function loadWorkspaceManifest() {
-    const manifestPath = manifestFilePath();
-    try {
-        const manifestModule = await import(pathToFileURL(manifestPath).href);
-        if (Array.isArray(manifestModule?.PACKAGE_MANIFEST)) {
-            return manifestModule.PACKAGE_MANIFEST;
-        }
-    }
-    catch (error) {
-        if (isManifestMissing(error))
-            return undefined;
-        throw error;
-    }
-    return undefined;
-}
-async function inferManifestFromWorkspace() {
-    const manifest = [];
-    const pkgJsonPaths = await findPackageJsonFiles(rootDir);
-    for (const pkgJsonPath of pkgJsonPaths) {
-        try {
-            const raw = await readFile(pkgJsonPath, 'utf8');
-            const json = JSON.parse(raw);
-            const pkgDir = path.dirname(pkgJsonPath);
-            const pkgName = json.name?.trim() || path.basename(pkgDir) || 'package';
-            manifest.push({
-                name: pkgName,
-                path: normalizeManifestPath(path.relative(rootDir, pkgDir)),
-                color: colorFromSeed(pkgName),
-                substitute: deriveSubstitute(pkgName),
-            });
-        }
-        catch {
-            continue;
-        }
-    }
-    return manifest;
-}
-function mergeManifestEntries(inferred, overrides) {
-    const normalizedOverrides = new Map();
-    overrides?.forEach((entry) => {
-        const normalized = normalizeManifestPath(entry.path);
-        if (!normalized)
-            return;
-        normalizedOverrides.set(normalized, { ...entry, path: normalized });
-    });
-    const merged = [];
-    for (const baseEntry of inferred) {
-        const normalized = normalizeManifestPath(baseEntry.path);
-        const override = normalizedOverrides.get(normalized);
-        if (override) {
-            normalizedOverrides.delete(normalized);
-            const name = override.name || baseEntry.name;
-            const color = override.color ?? baseEntry.color ?? colorFromSeed(name);
-            const substitute = override.substitute ?? baseEntry.substitute ?? deriveSubstitute(name) ?? name;
-            merged.push({ name, path: normalized, color, substitute });
-        }
-        else {
-            merged.push({ ...baseEntry, path: normalized });
-        }
-    }
-    normalizedOverrides.forEach((entry) => {
-        const name = entry.name || path.basename(entry.path) || 'package';
-        const color = entry.color ?? colorFromSeed(name);
-        const substitute = entry.substitute ?? deriveSubstitute(name) ?? name;
-        merged.push({ name, path: entry.path, color, substitute });
-    });
-    return merged;
-}
 async function ensureManifestState(forceReload = false) {
     if (manifestState && !forceReload)
         return manifestState;
     const [workspaceManifest, inferred] = await Promise.all([
-        loadWorkspaceManifest(),
-        inferManifestFromWorkspace(),
+        loadWorkspaceManifest(rootDir),
+        inferManifestFromWorkspace(rootDir),
     ]);
-    const entries = mergeManifestEntries(inferred, workspaceManifest);
+    const entries = mergeManifestEntries(rootDir, inferred, workspaceManifest);
     const byName = new Map(entries.map((pkg) => [pkg.name.toLowerCase(), pkg]));
     const byPath = new Map(entries.map((pkg) => [pkg.path.toLowerCase(), pkg]));
     manifestState = {
@@ -180,7 +36,7 @@ export async function loadPackages() {
             const meta = byPath.get(relativePath.toLowerCase()) ??
                 byName.get((pkgName ?? '').toLowerCase());
             const substitute = meta?.substitute ?? deriveSubstitute(pkgName) ?? path.basename(pkgDir);
-            const color = meta?.color ?? colorFromSeed(pkgName);
+            const color = (meta?.color ?? colorFromSeed(pkgName));
             let dockerfilePath;
             try {
                 const candidate = path.join(pkgDir, 'Dockerfile');

package/dist/utils/colors.js

@@ -1,11 +1,2 @@
 // 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),
-};
+export { colors } from '../colors-shared.js';

package/dist/utils/run.js

@@ -1,9 +1,9 @@
 // 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), '..', '..');
+// Always execute commands from the workspace where the CLI is invoked.
+// This makes installs from node_modules behave correctly instead of
+// running in the package's own directory.
+export const rootDir = process.cwd();
 export function run(command, args, options = {}) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {

package/dist/workspace.js

@@ -1,5 +1,7 @@
 // src/workspace.js
 import { spawnSync } from 'node:child_process';
+import { rm } from 'node:fs/promises';
+import path from 'node:path';
 import { run, rootDir } from './utils/run.js';
 import { logGlobal, logPkg, colors } from './utils/log.js';
 import { collectGitStatus, gitAdd, gitCommit } from './git.js';
@@ -191,12 +193,83 @@ function packageFilterArg(pkg) {
         return '.';
     return `./${pkg.relativeDir}`;
 }
+async function runLifecycleScenario(pkg, scenario) {
+    if (pkg) {
+        logPkg(pkg, scenario.singleMessage);
+        await run('pnpm', scenario.singleArgs(pkg));
+        return;
+    }
+    logGlobal(scenario.allMessage, colors.cyan);
+    await run('pnpm', scenario.allArgs);
+}
+const TYPECHECK_SCENARIO = {
+    allArgs: ['typecheck'],
+    allMessage: 'Running typecheck for all packages…',
+    singleArgs: (pkg) => ['run', '--filter', packageFilterArg(pkg), 'typecheck'],
+    singleMessage: 'Running typecheck…',
+};
+const BUILD_SCENARIO = {
+    allArgs: ['build'],
+    allMessage: 'Running build for all packages…',
+    singleArgs: (pkg) => ['run', '--filter', packageFilterArg(pkg), 'build'],
+    singleMessage: 'Running build…',
+};
+const TEST_SCENARIO = {
+    allArgs: ['test'],
+    allMessage: 'Running tests for all packages…',
+    singleArgs: (pkg) => [
+        'test',
+        '--',
+        pkg.relativeDir === '.' ? '.' : pkg.relativeDir,
+    ],
+    singleMessage: 'Running tests…',
+};
 export async function runCleanInstall() {
     logGlobal('Cleaning workspace…', colors.cyan);
     await run('pnpm', ['run', 'clean']);
     logGlobal('Reinstalling dependencies…', colors.cyan);
     await run('pnpm', ['install']);
 }
+const CLEAN_TARGETS = [
+    'node_modules',
+    'dist',
+    'build',
+    '.turbo',
+    '.next',
+    '.expo',
+    '.parcel-cache',
+    '.cache',
+    'coverage',
+    'tmp',
+    '.tmp',
+];
+async function removePath(target) {
+    try {
+        await rm(target, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        console.warn(colors.yellow(`  failed to remove ${target}: ${String(error)}`));
+        return false;
+    }
+}
+export async function cleanPackages(targets) {
+    for (const pkg of targets) {
+        logPkg(pkg, 'Cleaning build artifacts and caches…');
+        const results = await Promise.all(CLEAN_TARGETS.map(async (name) => {
+            const target = path.join(pkg.path, name);
+            const removed = await removePath(target);
+            return { name, removed };
+        }));
+        const removed = results.filter((r) => r.removed).map((r) => r.name);
+        if (removed.length === 0) {
+            console.log(colors.dim('  nothing to clean'));
+        }
+        else {
+            console.log(colors.dim(`  removed ${removed.join(', ')}`));
+        }
+    }
+}
 export async function updateDependencies(targets) {
     const preStatus = await collectGitStatus();
     if (targets.length === 1) {
@@ -231,32 +304,33 @@ export async function updateDependencies(targets) {
     logGlobal('Push complete.', colors.green);
 }
 export async function typecheckAll() {
-    logGlobal('Running typecheck for all packages…', colors.cyan);
-    await run('pnpm', ['typecheck']);
+    await runLifecycleScenario(undefined, TYPECHECK_SCENARIO);
 }
 export async function typecheckSingle(pkg) {
-    const filterArg = packageFilterArg(pkg);
-    logPkg(pkg, `Running typecheck…`);
-    await run('pnpm', ['run', '--filter', filterArg, 'typecheck']);
+    await runLifecycleScenario(pkg, TYPECHECK_SCENARIO);
 }
 export async function buildAll() {
-    logGlobal('Running build for all packages…', colors.cyan);
-    await run('pnpm', ['build']);
+    await runLifecycleScenario(undefined, BUILD_SCENARIO);
 }
 export async function buildSingle(pkg) {
-    const filterArg = packageFilterArg(pkg);
-    logPkg(pkg, `Running build…`);
-    await run('pnpm', ['run', '--filter', filterArg, 'build']);
+    await runLifecycleScenario(pkg, BUILD_SCENARIO);
+}
+export async function rebuildPackages(targets) {
+    await cleanPackages(targets);
+    if (targets.length === 1) {
+        await buildSingle(targets[0]);
+    }
+    else {
+        await buildAll();
+    }
 }
 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']);
+    await runLifecycleScenario(undefined, TEST_SCENARIO);
 }
 export async function testSingle(pkg) {
-    logPkg(pkg, `Running tests…`);
-    await run('pnpm', ['test', '--', pkg.relativeDir === '.' ? '.' : pkg.relativeDir]);
+    await runLifecycleScenario(pkg, TEST_SCENARIO);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",