@emeryld/manager 0.6.3 → 0.6.4

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/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.3",
+  "version": "0.6.4",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",