@emeryld/manager 0.4.6 → 0.5.1

package/README.md

@@ -30,7 +30,7 @@ Use `pnpm manager-cli create --describe <variant>` to print the scripts, key fil
 - `--skip-install` / `--skip-build` — bypass post-create steps when you want to install/build later
 
 ## Release helper (existing packages)
-- Run from the workspace root where `packages/` lives.
+- Run from the workspace root; the CLI discovers any workspace packages with a `package.json`.
 - `pnpm manager-cli` launches an interactive menu: pick packages, then run update → test → build → publish (or any single step).
 - Non-interactive publish: `pnpm manager-cli <pkg|all> --non-interactive --bump patch` (see CLI prompts for flags like `--sync` and `--tag`).
 

package/dist/create-package/index.js

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { stdin as input } from 'node:process';
 import { askLine, promptSingleKey } from '../prompts.js';
 import { colors, logGlobal } from '../utils/log.js';
+import { runHelperCli } from '../helper-cli.js';
+import { loadPackages } from '../packages.js';
 import { SCRIPT_DESCRIPTIONS, workspaceRoot, ensureWorkspaceToolingFiles, } from './shared.js';
 import { clientVariant } from './variants/client.js';
 import { contractVariant } from './variants/contract.js';
@@ -24,6 +26,58 @@ function derivePackageName(targetDir) {
     const base = path.basename(targetDir) || 'rrr-package';
     return base;
 }
+async function promptForContractNameWithHelper(title, options) {
+    let selection;
+    const scripts = options.map((opt) => ({
+        name: opt.label,
+        description: opt.meta ?? '',
+        emoji: '📦',
+        handler: () => {
+            selection = opt.value;
+        },
+    }));
+    scripts.push({
+        name: 'Enter manually',
+        emoji: '⌨️',
+        description: 'Type a contract package name',
+        handler: async () => {
+            const manual = await askLine('Contract package name (e.g. @scope/contract): ');
+            selection = manual.trim() || undefined;
+        },
+    });
+    scripts.push({
+        name: 'Skip (no contract)',
+        emoji: '⏭️',
+        description: 'Continue without a contract dependency',
+        handler: () => {
+            selection = undefined;
+        },
+    });
+    await runHelperCli({ title, scripts, argv: [] });
+    return selection;
+}
+async function promptForContractName() {
+    let packages = [];
+    try {
+        packages = await loadPackages();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'unknown error discovering packages';
+        logGlobal(`Could not auto-discover packages (${message}).`, colors.yellow);
+    }
+    const contractOptions = packages
+        .filter((pkg) => pkg.relativeDir !== '.')
+        .map((pkg) => ({
+        value: pkg.name,
+        label: pkg.name,
+        meta: pkg.relativeDir,
+    }));
+    if (contractOptions.length === 0) {
+        const manual = await askLine('Contract package name? (Enter to skip, e.g. @scope/contract): ');
+        return manual.trim() || undefined;
+    }
+    return promptForContractNameWithHelper('Select a contract package (or skip)', contractOptions);
+}
 function resolveVariant(key) {
     if (!key)
         return undefined;
@@ -372,11 +426,16 @@ async function gatherTarget(initial = {}) {
         : initial.pkgName;
     const pkgName = (nameAnswer || fallbackName).trim() || fallbackName;
     await ensureTargetDir(targetDir, { reset: initial.reset });
+    let contractName = initial.contractName;
+    if ((variant.id === 'rrr-server' || variant.id === 'rrr-client') &&
+        contractName === undefined) {
+        contractName = await promptForContractName();
+    }
     return {
         variant,
         targetDir,
         pkgName,
-        contractName: initial.contractName,
+        contractName,
         reset: initial.reset,
     };
 }

package/dist/create-package/variants/client.js

@@ -10,11 +10,19 @@ const CLIENT_SCRIPTS = [
     'clean',
     'test',
 ];
-const CONTRACT_IMPORT_PLACEHOLDER = '@your-scope/contract';
 export function clientIndexTs(contractImport) {
+    const contractImportLine = contractImport
+        ? `import { registry } from '${contractImport}'`
+        : "// TODO: import { registry } from '@your-scope/contract'";
+    const routeExports = contractImport
+        ? `export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+export const healthPost = routeClient.build(registry.byKey['POST /api/health'])`
+        : `// TODO: add route builders after wiring your contract registry
+// export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
+// export const healthPost = routeClient.build(registry.byKey['POST /api/health'])`;
     return `import { QueryClient } from '@tanstack/react-query'
 import { createRouteClient } from '@emeryld/rrroutes-client'
-import { registry } from '${contractImport}'
+${contractImportLine}
 
 const baseUrl = process.env.RRR_API_URL ?? 'http://localhost:4000'
 export const queryClient = new QueryClient()
@@ -25,22 +33,23 @@ export const routeClient = createRouteClient({
   environment: process.env.NODE_ENV === 'production' ? 'production' : 'development',
 })
 
-export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
-export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
+${routeExports}
 `;
 }
-export function clientPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER, options) {
+export function clientPackageJson(name, contractName, options) {
+    const dependencies = {
+        '@emeryld/rrroutes-client': '^2.5.3',
+        '@tanstack/react-query': '^5.90.12',
+        'socket.io-client': '^4.8.3',
+    };
+    if (contractName)
+        dependencies[contractName] = 'workspace:*';
     return basePackageJson({
         name,
         scripts: baseScripts('tsx watch src/index.ts', undefined, {
             includePrepare: options?.includePrepare,
         }),
-        dependencies: {
-            [contractName]: 'workspace:*',
-            '@emeryld/rrroutes-client': '^2.5.3',
-            '@tanstack/react-query': '^5.90.12',
-            'socket.io-client': '^4.8.3',
-        },
+        dependencies,
         devDependencies: {
             ...BASE_LINT_DEV_DEPENDENCIES,
             '@types/node': '^24.10.2',
@@ -76,7 +85,9 @@ async function clientFiles(pkgName, contractImport, targetDir) {
                 {
                     title: 'Usage',
                     lines: [
-                        `- Update the contract import in \`src/index.ts\` if needed (${contractImport}).`,
+                        contractImport
+                            ? `- Contract wired to ${contractImport}; adjust the import in \`src/index.ts\` if needed.`
+                            : '- Add your contract import to `src/index.ts` and wire the registry when ready.',
                         '- Use the exported `queryClient` and built route clients from `src/index.ts`.',
                     ],
                 },
@@ -96,11 +107,12 @@ export const clientVariant = {
     keyFiles: ['src/index.ts', 'README.md'],
     scripts: CLIENT_SCRIPTS,
     notes: [
+        'Pick a contract from discovered workspace packages (or skip) during scaffolding.',
         'Set the contract import via --contract or by editing src/index.ts.',
         'Exports query client + typed route builders to plug into React apps.',
     ],
     async scaffold(ctx) {
-        const contractImport = ctx.contractName ?? CONTRACT_IMPORT_PLACEHOLDER;
+        const contractImport = ctx.contractName;
         const files = await clientFiles(ctx.pkgName, contractImport, ctx.targetDir);
         for (const [relative, contents] of Object.entries(files)) {
             // eslint-disable-next-line no-await-in-loop

package/dist/create-package/variants/docker.js

@@ -149,49 +149,21 @@ import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { Docker } from 'docker-cli-js'
+import { runHelperCli } from '@emeryld/manager/dist/helper-cli.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
-const pkgRaw = await readFile(path.join(__dirname, '..', 'package.json'), 'utf8')
+const pkgRoot = path.join(__dirname, '..')
+const pkgRaw = await readFile(path.join(pkgRoot, 'package.json'), 'utf8')
 const pkg = JSON.parse(pkgRaw) as { name?: string }
 const image = \`\${pkg.name ?? '${pkgName}'}:latest\`
 const container =
-  (pkg.name ?? '${pkgName}').replace(/[^a-z0-9]/gi, '-').replace(/^-+|-+$/g, '') || 'rrr-service'
+  (pkg.name ?? '${pkgName}')
+    .replace(/[^a-z0-9]/gi, '-')
+    .replace(/^-+|-+$/g, '') || 'rrr-service'
 const port = process.env.PORT ?? '3000'
 const docker = new Docker({ spawnOptions: { stdio: 'inherit' } })
 
-async function main() {
-  const [command = 'help'] = process.argv.slice(2)
-  if (command === 'help') return printHelp()
-  if (command === 'build') return docker.command(\`build -t \${image} .\`)
-  if (command === 'up') {
-    await docker.command(\`build -t \${image} .\`)
-    return docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-  }
-  if (command === 'dev') {
-    await docker.command(\`build -t \${image} .\`)
-    await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-    return docker.command(\`logs -f \${container}\`)
-  }
-  if (command === 'run') {
-    return docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
-  }
-  if (command === 'logs') return docker.command(\`logs -f \${container}\`)
-  if (command === 'stop') return docker.command(\`stop \${container}\`)
-  if (command === 'clean') {
-    await safe(() => docker.command(\`stop \${container}\`))
-    await safe(() => docker.command(\`rm -f \${container}\`))
-    return
-  }
-  if (command === 'reset') {
-    await safe(() => docker.command(\`stop \${container}\`))
-    await safe(() => docker.command(\`rm -f \${container}\`))
-    await safe(() => docker.command(\`rmi -f \${image}\`))
-    return
-  }
-  return printHelp()
-}
-
 async function safe(run: () => Promise<unknown>) {
   try {
     await run()
@@ -216,9 +188,82 @@ function printHelp() {
   )
 }
 
-main().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.message : String(error))
-  process.exit(1)
+await runHelperCli({
+  title: 'Docker helper',
+  argv: process.argv.slice(2),
+  scripts: [
+    {
+      name: 'build',
+      emoji: '🔨',
+      description: 'docker build -t image .',
+      handler: () => docker.command(\`build -t \${image} .\`),
+    },
+    {
+      name: 'up',
+      emoji: '⬆️',
+      description: 'Build + run detached',
+      handler: async () => {
+        await docker.command(\`build -t \${image} .\`)
+        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
+      },
+    },
+    {
+      name: 'dev',
+      emoji: '🛠️',
+      description: 'Build, run, tail logs',
+      handler: async () => {
+        await docker.command(\`build -t \${image} .\`)
+        await docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`)
+        await docker.command(\`logs -f \${container}\`)
+      },
+    },
+    {
+      name: 'run',
+      emoji: '🏃',
+      description: 'Run existing image detached',
+      handler: () =>
+        docker.command(\`run -d --rm -p \${port}:\${port} --name \${container} \${image}\`),
+    },
+    {
+      name: 'logs',
+      emoji: '📜',
+      description: 'Tail docker logs',
+      handler: () => docker.command(\`logs -f \${container}\`),
+    },
+    {
+      name: 'stop',
+      emoji: '🛑',
+      description: 'Stop container',
+      handler: () => docker.command(\`stop \${container}\`),
+    },
+    {
+      name: 'clean',
+      emoji: '🧹',
+      description: 'Stop + remove container',
+      handler: async () => {
+        await safe(() => docker.command(\`stop \${container}\`))
+        await safe(() => docker.command(\`rm -f \${container}\`))
+      },
+    },
+    {
+      name: 'reset',
+      emoji: '♻️',
+      description: 'Clean container and remove image',
+      handler: async () => {
+        await safe(() => docker.command(\`stop \${container}\`))
+        await safe(() => docker.command(\`rm -f \${container}\`))
+        await safe(() => docker.command(\`rmi -f \${image}\`))
+      },
+    },
+    {
+      name: 'help',
+      emoji: 'ℹ️',
+      description: 'Print commands',
+      handler: () => {
+        printHelp()
+      },
+    },
+  ],
 })
 `;
 }

package/dist/create-package/variants/server.js

@@ -11,14 +11,30 @@ const SERVER_SCRIPTS = [
     'test',
     'start',
 ];
-const CONTRACT_IMPORT_PLACEHOLDER = '@your-scope/contract';
 export function serverIndexTs(contractImport) {
+    const contractImportLine = contractImport
+        ? `import { registry } from '${contractImport}'`
+        : "// import { registry } from '@your-scope/contract'";
+    const registerBlock = contractImport
+        ? `routes.registerControllers(registry, {
+  'GET /api/health': {
+    handler: async ({ ctx }) => ({
+      out: {
+        status: 'ok',
+        requestId: ctx.requestId,
+        at: new Date().toISOString(),
+      },
+    }),
+  },
+})`
+        : `// TODO: import your contract registry and register controllers
+// routes.registerControllers(registry)`;
     return `import 'dotenv/config'
 import http from 'node:http'
 import express from 'express'
 import cors from 'cors'
 import { createRRRoute } from '@emeryld/rrroutes-server'
-import { registry } from '${contractImport}'
+${contractImportLine}
 
 const app = express()
 app.use(cors({ origin: '*', credentials: true }))
@@ -38,17 +54,7 @@ const routes = createRRRoute(app, {
       : undefined,
 })
 
-routes.registerControllers(registry, {
-  'GET /api/health': {
-    handler: async ({ ctx }) => ({
-      out: {
-        status: 'ok',
-        requestId: ctx.requestId,
-        at: new Date().toISOString(),
-      },
-    }),
-  },
-})
+${registerBlock}
 
 const PORT = Number.parseInt(process.env.PORT ?? '4000', 10)
 const server = http.createServer(app)
@@ -58,21 +64,23 @@ server.listen(PORT, () => {
 })
 `;
 }
-export function serverPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER, options) {
+export function serverPackageJson(name, contractName, options) {
+    const dependencies = {
+        '@emeryld/rrroutes-server': '^2.4.1',
+        cors: '^2.8.5',
+        dotenv: '^16.4.5',
+        express: '^5.1.0',
+        zod: '^4.2.1',
+    };
+    if (contractName)
+        dependencies[contractName] = 'workspace:*';
     return basePackageJson({
         name,
         private: false,
         scripts: baseScripts('tsx watch --env-file .env src/index.ts', {
             start: 'node dist/index.js',
         }, { includePrepare: options?.includePrepare }),
-        dependencies: {
-            [contractName]: 'workspace:*',
-            '@emeryld/rrroutes-server': '^2.4.1',
-            cors: '^2.8.5',
-            dotenv: '^16.4.5',
-            express: '^5.1.0',
-            zod: '^4.2.1',
-        },
+        dependencies,
         devDependencies: {
             ...BASE_LINT_DEV_DEPENDENCIES,
             '@types/cors': '^2.8.5',
@@ -110,7 +118,9 @@ async function serverFiles(pkgName, contractImport, targetDir) {
                 {
                     title: 'Usage',
                     lines: [
-                        `- Update the contract import in \`src/index.ts\` if needed (${contractImport}).`,
+                        contractImport
+                            ? `- Contract wired to ${contractImport}; adjust the import in \`src/index.ts\` if needed.`
+                            : '- Add your contract import to `src/index.ts` when ready and register controllers.',
                         '- Start compiled server: `npm run start` after building.',
                     ],
                 },
@@ -130,11 +140,12 @@ export const serverVariant = {
     keyFiles: ['src/index.ts', '.env.example', 'README.md'],
     scripts: SERVER_SCRIPTS,
     notes: [
-        'Set the contract import via --contract or by editing src/index.ts.',
+        'Pick a contract from discovered workspace packages (or skip) during scaffolding.',
+        'Set/adjust the contract import via --contract or by editing src/index.ts.',
         'Includes start script for compiled output and dotenv-ready dev script.',
     ],
     async scaffold(ctx) {
-        const contractImport = ctx.contractName ?? CONTRACT_IMPORT_PLACEHOLDER;
+        const contractImport = ctx.contractName;
         const files = await serverFiles(ctx.pkgName, contractImport, ctx.targetDir);
         for (const [relative, contents] of Object.entries(files)) {
             // eslint-disable-next-line no-await-in-loop

package/dist/menu.js

@@ -4,7 +4,8 @@ import { releaseMultiple, releaseSingle } from './release.js';
 import { getOrderedPackages } from './packages.js';
 import { runHelperCli } from './helper-cli.js';
 import { ensureWorkingTreeCommitted } from './preflight.js';
-export function makeStepEntries(targets, packages, state) {
+import { run } from './utils/run.js';
+function makeManagerStepEntries(targets, packages, state) {
     return [
         {
             name: 'update dependencies',
@@ -84,12 +85,29 @@ export function makeStepEntries(targets, packages, state) {
         },
     ];
 }
+function makePackageScriptEntries(pkg) {
+    const scripts = pkg.json?.scripts ?? {};
+    const entries = [];
+    Object.entries(scripts)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .forEach(([name, command]) => {
+        entries.push({
+            name,
+            emoji: '▶️',
+            description: typeof command === 'string' ? command : '',
+            handler: async () => {
+                await run('pnpm', ['run', name], { cwd: pkg.path });
+            },
+        });
+    });
+    return entries;
+}
 export function buildPackageSelectionMenu(packages, onStepComplete) {
     const ordered = getOrderedPackages(packages);
     const entries = ordered.map((pkg) => ({
-        name: pkg.substitute,
+        name: pkg.name ?? pkg.substitute ?? pkg.dirName,
         emoji: colors[pkg.color]('●'),
-        description: pkg.name ?? pkg.dirName,
+        description: pkg.relativeDir ?? pkg.dirName,
         handler: async () => {
             const step = await runStepLoop([pkg], packages);
             onStepComplete?.(step);
@@ -112,6 +130,46 @@ export function buildPackageSelectionMenu(packages, onStepComplete) {
 // This removes the infinite loop and returns to the step menu after each run.
 export async function runStepLoop(targets, packages) {
     const state = {};
+    // Single package: show combined menu (manager actions + package.json scripts)
+    if (targets.length === 1) {
+        const pkg = targets[0];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const scriptEntries = makePackageScriptEntries(pkg);
+            const entries = [
+                {
+                    name: 'manager actions',
+                    emoji: globalEmoji,
+                    description: 'update/test/build/publish',
+                    handler: async () => {
+                        const managerEntries = makeManagerStepEntries(targets, packages, state);
+                        await runHelperCli({
+                            title: `Manager actions for ${pkg.name}`,
+                            scripts: managerEntries,
+                            argv: [],
+                        });
+                    },
+                },
+                ...scriptEntries,
+                {
+                    name: 'back',
+                    emoji: '↩️',
+                    description: 'Pick packages again',
+                    handler: () => {
+                        state.lastStep = 'back';
+                    },
+                },
+            ];
+            await runHelperCli({
+                title: `Actions for ${pkg.name}`,
+                scripts: entries,
+                argv: [],
+            });
+            if (state.lastStep === 'back')
+                return state.lastStep;
+            // loop to keep showing menu
+        }
+    }
     // Loop shows the step menu and executes a chosen action once.
     // After the handler completes, show the menu again.
     // Selecting "back" breaks and returns control to the package picker.
@@ -119,7 +177,7 @@ export async function runStepLoop(targets, packages) {
     // eslint-disable-next-line no-constant-condition
     while (true) {
         state.lastStep = undefined;
-        const entries = makeStepEntries(targets, packages, state);
+        const entries = makeManagerStepEntries(targets, packages, state);
         await runHelperCli({
             title: `Actions for ${targets.length === 1 ? targets[0].name : 'selected packages'}`,
             scripts: entries,

package/dist/packages.js

@@ -3,7 +3,16 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { readdir, readFile } from 'node:fs/promises';
 const rootDir = process.cwd();
-export const packagesDir = path.join(rootDir, 'packages');
+const ignoredDirs = new Set([
+    'node_modules',
+    '.git',
+    '.turbo',
+    '.next',
+    'dist',
+    'build',
+    '.cache',
+    'coverage',
+]);
 const colorPalette = ['cyan', 'green', 'yellow', 'magenta', 'red'];
 let manifestState;
 function manifestFilePath() {
@@ -19,7 +28,7 @@ function normalizeManifestPath(value) {
     const absolute = path.resolve(rootDir, value || '');
     let relative = path.relative(rootDir, absolute);
     if (!relative)
-        return '';
+        return '.';
     relative = relative.replace(/\\/g, '/');
     return relative.replace(/^(?:\.\/)+/, '');
 }
@@ -42,6 +51,35 @@ function deriveSubstitute(name) {
         .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 {
@@ -58,33 +96,26 @@ async function loadWorkspaceManifest() {
     return undefined;
 }
 async function inferManifestFromWorkspace() {
-    try {
-        const entries = await readdir(packagesDir, { withFileTypes: true });
-        const manifest = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const pkgJsonPath = path.join(packagesDir, entry.name, 'package.json');
-            try {
-                const raw = await readFile(pkgJsonPath, 'utf8');
-                const json = JSON.parse(raw);
-                const pkgName = json.name?.trim() || entry.name;
-                manifest.push({
-                    name: pkgName,
-                    path: normalizeManifestPath(path.relative(rootDir, path.join(packagesDir, entry.name))),
-                    color: colorFromSeed(pkgName),
-                    substitute: deriveSubstitute(pkgName),
-                });
-            }
-            catch {
-                continue;
-            }
+    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;
-    }
-    catch {
-        return [];
     }
+    return manifest;
 }
 function mergeManifestEntries(inferred, overrides) {
     const normalizedOverrides = new Map();
@@ -117,8 +148,8 @@ function mergeManifestEntries(inferred, overrides) {
     });
     return merged;
 }
-async function ensureManifestState() {
-    if (manifestState)
+async function ensureManifestState(forceReload = false) {
+    if (manifestState && !forceReload)
         return manifestState;
     const [workspaceManifest, inferred] = await Promise.all([
         loadWorkspaceManifest(),
@@ -136,35 +167,34 @@ async function ensureManifestState() {
     return manifestState;
 }
 export async function loadPackages() {
-    const entries = await readdir(packagesDir, { withFileTypes: true });
     const packages = [];
-    const { byName, byPath } = await ensureManifestState();
+    const { byName, byPath, entries } = await ensureManifestState(true);
     for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const pkgJsonPath = path.join(packagesDir, entry.name, 'package.json');
+        const pkgDir = path.resolve(rootDir, entry.path || '.');
+        const pkgJsonPath = path.join(pkgDir, 'package.json');
         try {
             const raw = await readFile(pkgJsonPath, 'utf8');
             const json = JSON.parse(raw);
-            const pkgName = json.name ?? entry.name;
-            const relativePath = normalizeManifestPath(path.relative(rootDir, path.join(packagesDir, entry.name)));
+            const pkgName = json.name?.trim() ?? entry.name;
+            const relativePath = normalizeManifestPath(path.relative(rootDir, pkgDir));
             const meta = byPath.get(relativePath.toLowerCase()) ??
-                byName.get(pkgName.toLowerCase());
-            const substitute = meta?.substitute ?? deriveSubstitute(pkgName) ?? entry.name;
+                byName.get((pkgName ?? '').toLowerCase());
+            const substitute = meta?.substitute ?? deriveSubstitute(pkgName) ?? path.basename(pkgDir);
             const color = meta?.color ?? colorFromSeed(pkgName);
             packages.push({
-                dirName: entry.name,
-                path: path.join(packagesDir, entry.name),
+                dirName: path.basename(pkgDir),
+                relativeDir: relativePath,
+                path: pkgDir,
                 packageJsonPath: pkgJsonPath,
                 json,
                 version: json.version,
-                name: pkgName,
+                name: pkgName ?? path.basename(pkgDir),
                 substitute,
                 color,
             });
         }
         catch (error) {
-            console.warn(`Skipping ${entry.name}: ${error}`);
+            console.warn(`Skipping ${entry.path || 'workspace root'}: ${String(error)}`);
         }
     }
     return packages;
@@ -175,10 +205,12 @@ export function resolvePackage(packages, key) {
     const normalized = key.toLowerCase();
     return packages.find((pkg) => {
         const dirMatch = pkg.dirName.toLowerCase() === normalized;
+        const pathMatch = pkg.relativeDir.toLowerCase() === normalized;
         const nameMatch = (pkg.name ?? '').toLowerCase() === normalized;
         const aliasMatch = (pkg.substitute ?? '').toLowerCase() === normalized;
-        const fuzzyMatch = (pkg.name ?? '').toLowerCase().includes(normalized);
-        return dirMatch || nameMatch || aliasMatch || fuzzyMatch;
+        const fuzzyMatch = (pkg.name ?? '').toLowerCase().includes(normalized) ||
+            pkg.relativeDir.toLowerCase().includes(normalized);
+        return dirMatch || pathMatch || nameMatch || aliasMatch || fuzzyMatch;
     });
 }
 /**
@@ -194,7 +226,7 @@ export function getOrderedPackages(packages) {
     for (const p of packages) {
         if (p.name)
             byName.set(p.name, p);
-        byDir.set(p.dirName, p);
+        byDir.set(p.relativeDir, p);
     }
     // Build adjacency list: edge dep -> pkg (dep must publish first)
     const depsOf = (p) => {
@@ -216,24 +248,24 @@ export function getOrderedPackages(packages) {
             .map((n) => byName.get(n))
             .filter((x) => Boolean(x));
     };
-    const nodes = new Set(packages.map((p) => p.dirName));
+    const nodes = new Set(packages.map((p) => p.relativeDir));
     const inDegree = new Map();
     const adj = new Map();
     for (const p of packages) {
-        inDegree.set(p.dirName, 0);
-        adj.set(p.dirName, new Set());
+        inDegree.set(p.relativeDir, 0);
+        adj.set(p.relativeDir, new Set());
     }
     for (const p of packages) {
         for (const dep of depsOf(p)) {
             // dep -> p
-            if (!nodes.has(dep.dirName))
+            if (!nodes.has(dep.relativeDir))
                 continue;
-            if (dep.dirName === p.dirName)
+            if (dep.relativeDir === p.relativeDir)
                 continue;
-            const set = adj.get(dep.dirName);
-            if (!set.has(p.dirName)) {
-                set.add(p.dirName);
-                inDegree.set(p.dirName, (inDegree.get(p.dirName) ?? 0) + 1);
+            const set = adj.get(dep.relativeDir);
+            if (!set.has(p.relativeDir)) {
+                set.add(p.relativeDir);
+                inDegree.set(p.relativeDir, (inDegree.get(p.relativeDir) ?? 0) + 1);
             }
         }
     }

package/dist/prompts.js

@@ -1,7 +1,9 @@
 // src/prompts.js
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
-export const publishCliState = { autoConfirmAll: false };
+export const publishCliState = {
+    autoDecision: undefined,
+};
 export function promptSingleKey(message, resolver) {
     const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY;
     if (!supportsRawMode) {
@@ -64,22 +66,26 @@ export async function askLine(question) {
     }
 }
 export async function promptYesNoAll(question) {
-    if (publishCliState.autoConfirmAll) {
-        console.log(`${question} (auto-confirmed via "all")`);
-        return 'yes';
+    if (publishCliState.autoDecision) {
+        console.log(`${question} (auto-${publishCliState.autoDecision} via "all")`);
+        return publishCliState.autoDecision;
     }
-    const result = await promptSingleKey(`${question} (y/n/a): `, (key) => {
-        if (key === 'y')
+    // Allow yes/no + "apply to all" variants: y, ya, n, na
+    // Use readline-style input to capture multi-character tokens consistently.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = (await askLine(`${question} (y/ya/n/na): `)).toLowerCase();
+        if (answer === 'y')
             return 'yes';
-        if (key === 'n')
+        if (answer === 'ya') {
+            publishCliState.autoDecision = 'yes';
+            return 'yes';
+        }
+        if (answer === 'n')
             return 'no';
-        if (key === 'a')
-            return 'all';
-        return undefined;
-    });
-    if (result === 'all') {
-        publishCliState.autoConfirmAll = true;
-        return 'yes';
+        if (answer === 'na') {
+            publishCliState.autoDecision = 'no';
+            return 'no';
+        }
     }
-    return result;
 }

package/dist/publish.js

@@ -134,9 +134,9 @@ async function main() {
     // If user provided non-interactive flags, run headless path
     if (parsed.nonInteractive) {
         if (packages.length === 0) {
-            throw new Error('No packages found in ./packages');
+            throw new Error('No packages with a package.json found in this workspace');
         }
-        publishCliState.autoConfirmAll = true;
+        publishCliState.autoDecision = 'yes';
         if (!parsed.selectionArg) {
             throw new Error('Non-interactive mode requires a package selection: <pkg> or "all".');
         }
@@ -153,7 +153,7 @@ async function main() {
         return;
     }
     if (packages.length === 0) {
-        logGlobal('No packages found in ./packages. Use "Create package" to scaffold one.', colors.yellow);
+        logGlobal('No packages found (no package.json discovered). Use "Create package" to scaffold one.', colors.yellow);
     }
     // Interactive flow (unchanged): selection menu then step menu
     if (parsed.selectionArg) {

package/dist/release.js

@@ -155,8 +155,8 @@ export async function promptVersionStrategy(targetPkg, selection, opts) {
         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)}`);
+        const marker = selection.length === 1 && pkg.relativeDir === targetPkg.relativeDir ? '*' : '•';
+        console.log(` ${marker} ${formatPkgName(pkg)} ${pkg.relativeDir} ${colors.yellow(pkg.version)}`);
     }
     console.log('\nSelect version strategy:');
     console.log(' 1) Patch');
@@ -228,7 +228,7 @@ export async function promptVersionStrategy(targetPkg, selection, opts) {
     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);
+        const others = selection.filter((pkg) => pkg.relativeDir !== targetPkg.relativeDir);
         if (others.length) {
             console.log('Other packages:');
             others.forEach((pkg) => {

package/dist/utils/log.js

@@ -5,7 +5,7 @@ export const globalEmoji = '🚀';
 export const formatPkgName = (pkg) => {
     const primary = pkg.substitute;
     const displayName = pkg.name ?? pkg.dirName;
-    const fileLabel = pkg.dirName;
+    const fileLabel = pkg.relativeDir || pkg.dirName;
     const colorizer = colors[pkg.color ?? defaultPackageColor];
     return `${colorizer(colors.bold(primary))} ${colors.dim(`(${displayName}) [${fileLabel}]`)}`;
 };

package/dist/workspace.js

@@ -26,24 +26,39 @@ function dependencyPathsFromStatus(status) {
         .map(extractPathFromStatus)
         .filter((p) => Boolean(p && dependencyFiles.has(p.split('/').pop() ?? '')));
 }
+function normalizePathForMatch(p) {
+    return p.replace(/\\/g, '/');
+}
+function findPackageForPath(p, targets) {
+    const normalized = normalizePathForMatch(p);
+    return targets.find((pkg) => {
+        const rel = normalizePathForMatch(pkg.relativeDir || '');
+        if (!rel || rel === '.')
+            return normalized === 'package.json';
+        const prefix = `${rel}/`;
+        return normalized === `${rel}/package.json` || normalized.startsWith(prefix);
+    });
+}
 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})`)}`);
+        const normalized = normalizePathForMatch(p);
+        const matchedPkg = findPackageForPath(normalized, targets);
+        if (matchedPkg) {
+            const rel = normalizePathForMatch(matchedPkg.relativeDir);
+            const base = rel === '.' ? '' : `${rel}/`;
+            const fileLabel = normalized.startsWith(base)
+                ? normalized.slice(base.length)
+                : normalized;
+            console.log(`  • ${colors.dim(`${formatPkgLabel(matchedPkg)} (${fileLabel || 'package.json'})`)}`);
             return;
         }
+        const file = normalized.split('/').pop() ?? '';
         if (file === 'pnpm-lock.yaml' ||
             file === 'package-lock.json' ||
             file === 'npm-shrinkwrap.json') {
@@ -100,16 +115,12 @@ function parseVersionChanges(path, 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';
+        const pkg = findPackageForPath(p, targets);
+        const label = pkg ? formatPkgLabel(pkg) : 'workspace';
         changes.push(...parseVersionChanges(p, label));
     });
     if (changes.length === 0)
@@ -133,15 +144,13 @@ function buildUpdateCommitMessage(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);
+        const matchedPkg = findPackageForPath(p, targets);
+        if (matchedPkg) {
+            labels.add(formatPkgLabel(matchedPkg));
             return;
         }
+        const parts = normalizePathForMatch(p).split('/');
         if (parts[parts.length - 1] === 'package.json') {
             labels.add('workspace deps');
         }
@@ -175,6 +184,13 @@ async function promptCommitMessage(proposed) {
     }
     return custom.trim();
 }
+function packageFilterArg(pkg) {
+    if (pkg.name)
+        return pkg.name;
+    if (!pkg.relativeDir || pkg.relativeDir === '.')
+        return '.';
+    return `./${pkg.relativeDir}`;
+}
 export async function runCleanInstall() {
     logGlobal('Cleaning workspace…', colors.cyan);
     await run('pnpm', ['run', 'clean']);
@@ -184,7 +200,7 @@ export async function runCleanInstall() {
 export async function updateDependencies(targets) {
     const preStatus = await collectGitStatus();
     if (targets.length === 1) {
-        const filterArg = targets[0].name ?? `./packages/${targets[0].dirName}`;
+        const filterArg = packageFilterArg(targets[0]);
         logPkg(targets[0], `Updating dependencies…`);
         await run('pnpm', ['-r', '--filter', filterArg, 'update']);
     }
@@ -219,7 +235,7 @@ export async function typecheckAll() {
     await run('pnpm', ['typecheck']);
 }
 export async function typecheckSingle(pkg) {
-    const filterArg = pkg.name ?? `./packages/${pkg.dirName}`;
+    const filterArg = packageFilterArg(pkg);
     logPkg(pkg, `Running typecheck…`);
     await run('pnpm', ['run', '--filter', filterArg, 'typecheck']);
 }
@@ -228,7 +244,7 @@ export async function buildAll() {
     await run('pnpm', ['build']);
 }
 export async function buildSingle(pkg) {
-    const filterArg = pkg.name ?? `./packages/${pkg.dirName}`;
+    const filterArg = packageFilterArg(pkg);
     logPkg(pkg, `Running build…`);
     await run('pnpm', ['run', '--filter', filterArg, 'build']);
 }
@@ -242,5 +258,5 @@ export async function testAll() {
 }
 export async function testSingle(pkg) {
     logPkg(pkg, `Running tests…`);
-    await run('pnpm', ['test', '--', `packages/${pkg.dirName}`]);
+    await run('pnpm', ['test', '--', pkg.relativeDir === '.' ? '.' : pkg.relativeDir]);
 }

package/package.json

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