@emeryld/manager 0.6.4 → 0.6.6

package/dist/colors-shared.js

@@ -0,0 +1,11 @@
+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),
+    gray: ansi(90),
+};

package/dist/helper-cli/display.js

@@ -45,5 +45,5 @@ export function printPaginatedScriptList(state, title) {
         const display = option.enabled ? label : colors.dim(label);
         console.log(`  ${numberLabel} ${icon} ${display}`);
     });
-    console.log(colors.dim(`Enter 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} for previous page, ${NEXT_KEY} for next page, ${BACK_KEY} to go back, or type a name.`));
+    console.log(colors.dim(`Enter 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} for previous page (if shown), ${NEXT_KEY} for next page (if shown), ${BACK_KEY} to go back, or type a name.`));
 }

package/dist/helper-cli/pagination.js

@@ -15,18 +15,22 @@ export function buildVisibleOptions(entries, page) {
     }));
     const hasPrevious = safePage > 0;
     const hasNext = safePage < pageCount - 1;
-    options.push({
-        type: 'nav',
-        action: 'previous',
-        hotkey: PREVIOUS_KEY,
-        enabled: hasPrevious,
-    });
-    options.push({
-        type: 'nav',
-        action: 'next',
-        hotkey: NEXT_KEY,
-        enabled: hasNext,
-    });
+    if (hasPrevious) {
+        options.push({
+            type: 'nav',
+            action: 'previous',
+            hotkey: PREVIOUS_KEY,
+            enabled: true,
+        });
+    }
+    if (hasNext) {
+        options.push({
+            type: 'nav',
+            action: 'next',
+            hotkey: NEXT_KEY,
+            enabled: true,
+        });
+    }
     options.push({
         type: 'nav',
         action: 'back',

package/dist/helper-cli/prompts.js

@@ -86,7 +86,7 @@ function formatInteractiveLines(state, selectedIndex, title) {
         lines.push(`${pointer}${numberLabel}. ${icon} ${navLabel}`);
     });
     lines.push('');
-    lines.push(colors.dim(`Use ↑/↓ (or j/k) to move, 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} prev page, ${NEXT_KEY} next page, ${BACK_KEY} back, Enter to confirm, Esc/Ctrl+C to exit.`));
+    lines.push(colors.dim(`Use ↑/↓ (or j/k) to move, 1-${PAGE_SIZE} to run, ${PREVIOUS_KEY} prev page (when shown), ${NEXT_KEY} next page (when shown), ${BACK_KEY} back, Enter to confirm, Esc/Ctrl+C to exit.`));
     return lines;
 }
 function renderInteractiveList(lines, previousLineCount) {

package/dist/menu/script-helpers.js

@@ -1,5 +1,48 @@
 import { colors } from "../utils/log.js";
 import { run } from "../utils/run.js";
+const FRONTEND_INDICATORS = [
+    { dep: 'next', label: 'Next' },
+    { dep: 'remix', label: 'Remix' },
+    { dep: '@remix-run/node', label: 'Remix' },
+    { dep: 'expo', label: 'Expo' },
+    { dep: 'react-native', label: 'React Native' },
+    { dep: 'react', label: 'React' },
+    { dep: 'vite', label: 'Vite' },
+    { dep: '@vitejs/plugin-react', label: 'Vite' },
+    { dep: 'svelte', label: 'Svelte' },
+    { dep: '@sveltejs/vite-plugin-svelte', label: 'SvelteKit' },
+    { dep: '@angular/core', label: 'Angular' },
+    { dep: 'vue', label: 'Vue' },
+];
+const BACKEND_INDICATORS = [
+    { dep: 'express', label: 'Express' },
+    { dep: 'fastify', label: 'Fastify' },
+    { dep: 'koa', label: 'Koa' },
+    { dep: 'hono', label: 'Hono' },
+    { dep: '@nestjs/core', label: 'NestJS' },
+    { dep: '@trpc/server', label: 'tRPC' },
+];
+const CLI_INDICATORS = [
+    { dep: '@oclif/core', label: 'OClif' },
+    { dep: '@oclif/command', label: 'OClif' },
+    { dep: 'oclif', label: 'OClif' },
+    { dep: 'commander', label: 'Commander' },
+    { dep: 'yargs', label: 'Yargs' },
+    { dep: 'cac', label: 'CAC' },
+    { dep: 'clipanion', label: 'Clipanion' },
+    { dep: 'caporal', label: 'Caporal' },
+    { dep: 'ink', label: 'Ink' },
+    { dep: 'meow', label: 'Meow' },
+    { dep: 'enquirer', label: 'Enquirer' },
+    { dep: 'zx', label: 'ZX' },
+];
+const CLI_KEYWORDS = new Set(['cli', 'command-line', 'commandline', 'tooling']);
+const KIND_COLOR_MAP = {
+    frontend: colors.magenta,
+    backend: colors.green,
+    library: colors.cyan,
+    cli: colors.red,
+};
 export function collectDependencies(pkg) {
     return new Set([
         ...Object.keys(pkg.json?.dependencies ?? {}),
@@ -37,6 +80,7 @@ function resolveFormatScript(pkg, scripts, dependencies) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     return {
@@ -56,6 +100,7 @@ function resolveTypecheckScript(pkg, scripts, dependencies) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     return {
@@ -75,6 +120,7 @@ function resolveLintScript(pkg, scripts, dependencies) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     return {
@@ -86,7 +132,7 @@ function resolveLintScript(pkg, scripts, dependencies) {
 function resolveDevScript(pkg, scripts, dependencies, kind) {
     const devCandidates = kind === 'frontend'
         ? ['dev', 'start', 'serve']
-        : kind === 'backend'
+        : kind === 'backend' || kind === 'cli'
             ? ['dev', 'start', 'watch', 'serve', 'start:dev']
             : ['dev', 'start'];
     const direct = resolveRunScript(scripts, devCandidates);
@@ -99,6 +145,7 @@ function resolveDevScript(pkg, scripts, dependencies, kind) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     if (dependencies.has('vite')) {
@@ -108,6 +155,7 @@ function resolveDevScript(pkg, scripts, dependencies, kind) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     if (dependencies.has('expo')) {
@@ -117,6 +165,7 @@ function resolveDevScript(pkg, scripts, dependencies, kind) {
             description: commandDescription(args),
             args,
             available: true,
+            isDefault: true,
         };
     }
     return {
@@ -145,7 +194,9 @@ export function makeBaseScriptEntries(pkg) {
     return BASE_SCRIPT_KEYS.map((key) => {
         const resolution = resolveBaseScript(pkg, key, scripts, dependencies, marker.kind);
         const description = resolution.available
-            ? resolution.description
+            ? resolution.isDefault
+                ? `${resolution.description} (default)`
+                : resolution.description
             : `No ${key} command detected`;
         return {
             name: key,
@@ -162,17 +213,73 @@ export function makeBaseScriptEntries(pkg) {
     });
 }
 export function getPackageMarker(pkg, dependencies = collectDependencies(pkg)) {
-    const hasFrontend = ['react', 'next', 'expo', 'react-native', 'vite'].some((dep) => dependencies.has(dep));
-    const hasBackend = ['express', 'fastify', 'hono', 'koa', '@nestjs/core'].some((dep) => dependencies.has(dep));
+    const normalizedDeps = new Set([...dependencies].map((dep) => String(dep).toLowerCase().trim()));
+    function findIndicator(indicators) {
+        for (const indicator of indicators) {
+            if (normalizedDeps.has(indicator.dep.toLowerCase())) {
+                return indicator;
+            }
+        }
+        return undefined;
+    }
     const pkgType = pkg.json?.type?.toLowerCase();
-    if (hasFrontend) {
-        return { label: 'frontend', colorize: colors.magenta, kind: 'frontend' };
+    const keywords = (() => {
+        const raw = pkg.json?.keywords;
+        if (typeof raw === 'string') {
+            return raw
+                .split(/\s*,\s*/)
+                .map((keyword) => keyword.trim())
+                .filter(Boolean);
+        }
+        if (Array.isArray(raw)) {
+            return raw
+                .map((keyword) => String(keyword).trim())
+                .filter(Boolean);
+        }
+        return [];
+    })();
+    const hasCliKeyword = keywords
+        .map((keyword) => keyword.toLowerCase())
+        .some((keyword) => CLI_KEYWORDS.has(keyword));
+    const hasBinField = !!pkg.json?.bin &&
+        (typeof pkg.json?.bin === 'string' ||
+            typeof pkg.json?.bin === 'object' ||
+            Array.isArray(pkg.json?.bin));
+    const frontendIndicator = findIndicator(FRONTEND_INDICATORS);
+    if (frontendIndicator) {
+        return {
+            label: frontendIndicator.label ?? frontendIndicator.dep,
+            colorize: KIND_COLOR_MAP.frontend,
+            kind: 'frontend',
+            kindColorize: KIND_COLOR_MAP.frontend,
+        };
     }
-    if (hasBackend) {
-        return { label: 'backend', colorize: colors.green, kind: 'backend' };
+    const backendIndicator = findIndicator(BACKEND_INDICATORS);
+    if (backendIndicator) {
+        return {
+            label: backendIndicator.label ?? backendIndicator.dep,
+            colorize: KIND_COLOR_MAP.backend,
+            kind: 'backend',
+            kindColorize: KIND_COLOR_MAP.backend,
+        };
     }
-    if (pkgType === 'module') {
-        return { label: 'esm', colorize: colors.yellow, kind: 'library' };
+    const cliIndicator = findIndicator(CLI_INDICATORS);
+    if (cliIndicator || hasCliKeyword || hasBinField) {
+        const label = cliIndicator?.label ?? 'CLI';
+        return {
+            label,
+            colorize: KIND_COLOR_MAP.cli,
+            kind: 'cli',
+            kindColorize: KIND_COLOR_MAP.cli,
+        };
     }
-    return { label: 'node', colorize: colors.cyan, kind: 'library' };
+    const isModule = pkgType === 'module';
+    const label = isModule ? 'ESM' : 'Node';
+    const labelColorizer = isModule ? colors.yellow : colors.cyan;
+    return {
+        label,
+        colorize: labelColorizer,
+        kind: 'library',
+        kindColorize: KIND_COLOR_MAP.library,
+    };
 }

package/dist/menu.js

@@ -9,6 +9,11 @@ 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 formatKindLabel(kind) {
+    if (kind === 'cli')
+        return 'CLI';
+    return `${kind.charAt(0).toUpperCase()}${kind.slice(1)}`;
+}
 function makeManagerStepEntries(targets, packages, state, options) {
     const includeBack = options?.includeBack ?? true;
     return [
@@ -154,12 +159,15 @@ export function buildPackageSelectionMenu(packages, onStepComplete) {
     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}` : '';
+        const descriptionMeta = colors.dim(pkg.relativeDir ?? pkg.dirName);
+        const labelBadge = marker.label ? marker.colorize(marker.label) : '';
+        const kindLabel = formatKindLabel(marker.kind);
+        const kindBadge = marker.kindColorize(kindLabel);
+        const badgeMeta = [labelBadge, kindBadge].filter(Boolean).join(' ');
         return {
             name: pkg.name ?? pkg.substitute ?? pkg.dirName,
             emoji: marker.colorize('●'),
-            description: `${descriptionMeta}${colors.dim(markerHint)}`,
+            description: [descriptionMeta, badgeMeta].filter(Boolean).join(' '),
             color: pkgColor,
             handler: async () => {
                 const step = await runStepLoop([pkg], packages);

package/dist/packages/manifest-utils.js

@@ -0,0 +1,145 @@
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const DEFAULT_COLOR_PALETTE = ['cyan', 'green', 'yellow', 'magenta', 'red'];
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.turbo',
+    '.next',
+    'dist',
+    'build',
+    '.cache',
+    'coverage',
+]);
+export function manifestFilePath(rootDir) {
+    return path.join(rootDir, 'scripts', 'packages.mjs');
+}
+export function normalizeManifestPath(rootDir, value) {
+    const absolute = path.resolve(rootDir, value || '');
+    let relative = path.relative(rootDir, absolute);
+    if (!relative)
+        return '.';
+    relative = relative.replace(/\\/g, '/');
+    return relative.replace(/^(?:\.\/)+/, '');
+}
+export async function findPackageJsonFiles(rootDir) {
+    const results = new Set();
+    const queue = [rootDir];
+    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 (IGNORED_DIRS.has(entry.name))
+                continue;
+            queue.push(path.join(current, entry.name));
+        }
+    }
+    return [...results].sort();
+}
+export async function loadWorkspaceManifest(rootDir) {
+    const manifestPath = manifestFilePath(rootDir);
+    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;
+}
+export async function inferManifestFromWorkspace(rootDir) {
+    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 || path.basename(pkgDir)).trim() || 'package';
+            manifest.push({
+                name: pkgName,
+                path: normalizeManifestPath(rootDir, path.relative(rootDir, pkgDir)),
+                color: colorFromSeed(pkgName),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return manifest;
+}
+export function mergeManifestEntries(rootDir, inferred, overrides) {
+    const normalizedOverrides = new Map();
+    overrides?.forEach((entry) => {
+        const normalized = normalizeManifestPath(rootDir, entry.path);
+        if (!normalized)
+            return;
+        normalizedOverrides.set(normalized, { ...entry, path: normalized });
+    });
+    const merged = [];
+    for (const baseEntry of inferred) {
+        const normalized = normalizeManifestPath(rootDir, 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);
+            merged.push({ name, path: normalized, color });
+        }
+        else {
+            merged.push({ ...baseEntry, path: normalized });
+        }
+    }
+    normalizedOverrides.forEach((entry) => {
+        const name = entry.name || path.basename(entry.path) || 'package';
+        const color = entry.color ?? colorFromSeed(name);
+        merged.push({ name, path: entry.path, color });
+    });
+    return merged;
+}
+export 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 DEFAULT_COLOR_PALETTE[hash % DEFAULT_COLOR_PALETTE.length];
+}
+export 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;
+}
+function isManifestMissing(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const code = error.code;
+    return code === 'ERR_MODULE_NOT_FOUND' || code === 'ENOENT';
+}
+export { DEFAULT_COLOR_PALETTE };

package/dist/sync-version.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { colorFromSeed, inferManifestFromWorkspace, loadWorkspaceManifest, mergeManifestEntries, } from './packages/manifest-utils.js';
+import { colors } from './colors-shared.js';
+const rootDir = process.cwd();
+const registerPackageEntry = (map, pkgPath, entry) => {
+    if (!map.has(pkgPath)) {
+        map.set(pkgPath, entry);
+    }
+};
+async function collectPackageEntries() {
+    const records = new Map();
+    const [workspaceManifest, inferred] = await Promise.all([
+        loadWorkspaceManifest(rootDir),
+        inferManifestFromWorkspace(rootDir),
+    ]);
+    const manifestEntries = mergeManifestEntries(rootDir, inferred, workspaceManifest);
+    for (const manifestEntry of manifestEntries) {
+        if (!manifestEntry.path)
+            continue;
+        const pkgPath = path.join(rootDir, manifestEntry.path, 'package.json');
+        registerPackageEntry(records, pkgPath, {
+            name: manifestEntry.name,
+            pkgPath,
+            color: manifestEntry.color ?? colorFromSeed(manifestEntry.name),
+        });
+    }
+    return Array.from(records.values());
+}
+async function main() {
+    const version = process.argv[2];
+    if (!version) {
+        console.error('Usage: pnpm sync <version>');
+        process.exitCode = 1;
+        return;
+    }
+    const semverPattern = /^\d+\.\d+\.\d+(?:[-+].*)?$/;
+    if (!semverPattern.test(version)) {
+        console.error(`Invalid version "${version}". Expected semver (e.g. 1.6.0).`);
+        process.exitCode = 1;
+        return;
+    }
+    const packageEntries = await collectPackageEntries();
+    await Promise.all(packageEntries.map(async (entry) => {
+        if (!existsSync(entry.pkgPath)) {
+            console.warn(`${colors[entry.color ?? 'cyan']('●')} ${colors.yellow(`Skipping missing package file: ${path.relative(rootDir, entry.pkgPath)}`)}`);
+            return;
+        }
+        const raw = await readFile(entry.pkgPath, 'utf8');
+        const json = JSON.parse(raw);
+        const previousVersion = json.version ?? 'unknown';
+        json.version = version;
+        const formatted = `${JSON.stringify(json, null, 2)}\n`;
+        await writeFile(entry.pkgPath, formatted);
+        console.log(`${colors[entry.color ?? 'cyan']('●')} ${colors.cyan('[sync]')} ${path.relative(rootDir, entry.pkgPath)} ${colors.dim(`${previousVersion} -> ${version}`)}`);
+    }));
+}
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/package.json

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

package/tsconfig.base.json

@@ -3,6 +3,7 @@
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
+    "allowJs": true,
     "rootDir": "src",
     "outDir": "dist",
     "lib": ["ES2022"],