@emeryld/manager 0.4.5 → 0.5.0

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,7 +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 { SCRIPT_DESCRIPTIONS, workspaceRoot, } from './shared.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';
 import { dockerVariant } from './variants/docker.js';
@@ -24,6 +25,49 @@ function derivePackageName(targetDir) {
     const base = path.basename(targetDir) || 'rrr-package';
     return base;
 }
+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 candidates = packages
+        .filter((pkg) => pkg.relativeDir !== '.')
+        .map((pkg, index) => ({
+        label: `${pkg.name}${pkg.relativeDir ? colors.dim(` (${pkg.relativeDir})`) : ''}`,
+        value: pkg.name,
+        index,
+    }));
+    if (candidates.length === 0) {
+        const manual = await askLine('Contract package name? (Enter to skip, e.g. @scope/contract): ');
+        return manual.trim() || undefined;
+    }
+    console.log(colors.magenta('Select a contract package (or skip):'));
+    candidates.forEach((opt, idx) => {
+        const prefix = colors.cyan(String(idx + 1).padStart(2, ' '));
+        console.log(`  [${prefix}] ${opt.label}`);
+    });
+    console.log(`  [${colors.cyan('m ')}] Enter manually`);
+    console.log(`  [${colors.cyan('s ')}] Skip (no contract)`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const choice = (await askLine('Choice: ')).trim().toLowerCase();
+        if (!choice || choice === 's')
+            return undefined;
+        if (choice === 'm') {
+            const manual = await askLine('Contract package name (e.g. @scope/contract): ');
+            return manual.trim() || undefined;
+        }
+        const idx = Number.parseInt(choice, 10);
+        if (Number.isInteger(idx) && idx >= 1 && idx <= candidates.length) {
+            return candidates[idx - 1].value;
+        }
+        console.log(colors.yellow('Enter a number, "m" to type a name, or "s" to skip.'));
+    }
+}
 function resolveVariant(key) {
     if (!key)
         return undefined;
@@ -372,17 +416,24 @@ 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,
     };
 }
 export async function createRrrPackage(options = {}) {
     const target = await gatherTarget(options);
     logGlobal(`Creating ${target.variant.label} in ${path.relative(workspaceRoot, target.targetDir) || '.'}`, colors.green);
+    const toolingRoot = target.variant.id === 'rrr-fullstack' ? target.targetDir : workspaceRoot;
+    await ensureWorkspaceToolingFiles(toolingRoot);
     await target.variant.scaffold({
         targetDir: target.targetDir,
         pkgName: target.pkgName,

package/dist/create-package/shared.js

@@ -1,7 +1,11 @@
 import { readFileSync } from 'node:fs';
 import { access, mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { promptYesNoAll } from '../prompts.js';
 export const workspaceRoot = process.cwd();
+export function isWorkspaceRoot(dir) {
+    return path.resolve(dir) === path.resolve(workspaceRoot);
+}
 function pathExists(target) {
     return access(target)
         .then(() => true)
@@ -31,26 +35,45 @@ export async function writeFileIfMissing(baseDir, relative, contents) {
     console.log(`  created ${rel}`);
     return 'created';
 }
+export async function writeFileWithPrompt(baseDir, relative, contents) {
+    const fullPath = path.join(baseDir, relative);
+    await mkdir(path.dirname(fullPath), { recursive: true });
+    const rel = path.relative(workspaceRoot, fullPath);
+    const exists = await pathExists(fullPath);
+    if (exists) {
+        const answer = await promptYesNoAll(`Overwrite existing ${rel}?`);
+        if (answer !== 'yes') {
+            console.log(`  kept existing ${rel}`);
+            return 'skipped';
+        }
+    }
+    await writeFile(fullPath, contents, 'utf8');
+    console.log(`  ${exists ? 'updated' : 'created'} ${rel}`);
+    return exists ? 'updated' : 'created';
+}
 export function baseTsConfig(options) {
     const config = {
         ...(options?.extends ? { extends: options.extends } : {}),
         compilerOptions: {
             target: 'ES2020',
-            module: 'NodeNext',
-            moduleResolution: 'NodeNext',
-            outDir: options?.outDir ?? 'dist',
-            rootDir: options?.rootDir ?? 'src',
-            declaration: true,
-            sourceMap: true,
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
+            module: 'ESNext',
+            moduleResolution: 'Bundler',
+            ...(options?.outDir ? { outDir: options.outDir } : {}),
+            ...(options?.rootDir ? { rootDir: options.rootDir } : {}),
+            declaration: options?.declaration ?? true,
+            sourceMap: options?.sourceMap ?? true,
+            strict: options?.strict ?? true,
+            esModuleInterop: options?.esModuleInterop ?? true,
+            skipLibCheck: options?.skipLibCheck ?? true,
+            resolveJsonModule: options?.resolveJsonModule ?? true,
+            forceConsistentCasingInFileNames: options?.forceConsistentCasingInFileNames ?? true,
+            baseUrl: options?.baseUrl ?? '.',
             lib: options?.lib,
             types: options?.types,
             jsx: options?.jsx,
         },
-        include: options?.include ?? ['src/**/*'],
-        exclude: options?.exclude ?? ['dist', 'node_modules'],
+        include: options?.include,
+        exclude: options?.exclude,
     };
     return `${JSON.stringify(config, null, 2)}\n`;
 }
@@ -145,7 +168,8 @@ const DEFAULT_GITIGNORE_ENTRIES = [
 export function gitignoreFrom(entries = DEFAULT_GITIGNORE_ENTRIES) {
     return entries.join('\n');
 }
-export function baseScripts(devCommand, extras) {
+export function baseScripts(devCommand, extras, options) {
+    const includePrepare = options?.includePrepare ?? true;
     return {
         dev: devCommand,
         build: 'tsc -p tsconfig.json',
@@ -157,18 +181,36 @@ export function baseScripts(devCommand, extras) {
         'format:check': 'prettier . --check',
         clean: 'rimraf dist .turbo coverage',
         test: "node -e \"console.log('No tests yet')\"",
-        prepare: 'husky install || true',
+        ...(includePrepare
+            ? { prepare: 'git rev-parse --is-inside-work-tree >/dev/null 2>&1 && husky || true' }
+            : {}),
         ...extras,
     };
 }
 export function basePackageFiles(options) {
     return {
-        'eslint.config.js': baseEslintConfig(options?.tsconfigPath),
+        '.gitignore': gitignoreFrom(options?.gitignoreEntries),
+    };
+}
+export async function ensureWorkspaceToolingFiles(baseDir, options) {
+    const defaultTsconfig = path.join(baseDir, 'tsconfig.json');
+    const resolvedRootConfig = options?.tsconfigPath
+        ? path.resolve(baseDir, options.tsconfigPath)
+        : await resolveRootTsconfig(baseDir);
+    const tsconfigPath = toPosixPath(path.relative(baseDir, resolvedRootConfig ?? defaultTsconfig) || './tsconfig.json');
+    const files = workspaceToolingFiles(tsconfigPath);
+    for (const [relative, contents] of Object.entries(files)) {
+        // eslint-disable-next-line no-await-in-loop
+        await writeFileWithPrompt(baseDir, relative, contents);
+    }
+}
+export function workspaceToolingFiles(tsconfigPath) {
+    return {
+        'eslint.config.js': baseEslintConfig(tsconfigPath),
         'prettier.config.js': basePrettierConfig(),
         '.prettierignore': `${PRETTIER_IGNORE}\n`,
         '.vscode/settings.json': vscodeSettings(),
         '.husky/pre-commit': HUSKY_PRE_COMMIT,
-        '.gitignore': gitignoreFrom(options?.gitignoreEntries),
     };
 }
 export const SCRIPT_DESCRIPTIONS = {
@@ -261,27 +303,55 @@ function readRootPackageManager() {
         return undefined;
     }
 }
-async function resolveRootTsconfig() {
+async function resolveRootTsconfig(baseDir = workspaceRoot) {
     const candidates = ['tsconfig.base.json', 'tsconfig.json'];
     for (const candidate of candidates) {
-        const fullPath = path.join(workspaceRoot, candidate);
+        const fullPath = path.join(baseDir, candidate);
         if (await pathExists(fullPath)) {
             return fullPath;
         }
     }
     return undefined;
 }
+async function findNearestTsconfig(startDir) {
+    let current = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const found = await resolveRootTsconfig(current);
+        if (found)
+            return found;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
 export async function packageTsConfig(targetDir, options) {
     const extendsFromRoot = options?.extendsFromRoot ?? true;
     let extendsPath;
     if (extendsFromRoot) {
-        const rootConfig = await resolveRootTsconfig();
+        const rootConfig = await findNearestTsconfig(targetDir);
         if (rootConfig) {
             const relative = path.relative(targetDir, rootConfig);
-            if (relative !== '') {
-                extendsPath = toPosixPath(relative || './tsconfig.json');
-            }
+            const normalized = toPosixPath(relative || './tsconfig.base.json');
+            extendsPath = normalized.startsWith('.') ? normalized : `./${normalized}`;
         }
     }
-    return baseTsConfig({ ...options, extends: extendsPath });
+    const compilerOptions = stripUndefined({
+        rootDir: options?.rootDir ?? 'src',
+        outDir: options?.outDir ?? 'dist',
+        tsBuildInfoFile: 'dist/.tsbuildinfo',
+        jsx: options?.jsx,
+        types: options?.types,
+        lib: options?.lib,
+        esModuleInterop: options?.esModuleInterop ?? true,
+        allowSyntheticDefaultImports: options?.esModuleInterop ?? true,
+        skipLibCheck: options?.skipLibCheck ?? true,
+    });
+    const config = stripUndefined({
+        extends: extendsPath,
+        compilerOptions,
+        include: options?.include ?? ['src/**/*.ts'],
+    });
+    return `${JSON.stringify(config, null, 2)}\n`;
 }

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

@@ -1,4 +1,4 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const CLIENT_SCRIPTS = [
     'dev',
     'build',
@@ -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,20 +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) {
+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'),
-        dependencies: {
-            [contractName]: 'workspace:*',
-            '@emeryld/rrroutes-client': '^2.5.3',
-            '@tanstack/react-query': '^5.90.12',
-            'socket.io-client': '^4.8.3',
-        },
+        scripts: baseScripts('tsx watch src/index.ts', undefined, {
+            includePrepare: options?.includePrepare,
+        }),
+        dependencies,
         devDependencies: {
             ...BASE_LINT_DEV_DEPENDENCIES,
             '@types/node': '^24.10.2',
@@ -46,12 +57,15 @@ export function clientPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLD
     });
 }
 async function clientFiles(pkgName, contractImport, targetDir) {
+    const includePrepare = isWorkspaceRoot(targetDir);
     const tsconfig = await packageTsConfig(targetDir, {
+        include: ['src/**/*.ts', 'src/**/*.tsx'],
         lib: ['ES2020', 'DOM'],
-        types: ['node'],
+        types: ['react', 'react-native'],
+        jsx: 'react-jsx',
     });
     return {
-        'package.json': clientPackageJson(pkgName, contractImport),
+        'package.json': clientPackageJson(pkgName, contractImport, { includePrepare }),
         'tsconfig.json': tsconfig,
         ...basePackageFiles(),
         'src/index.ts': clientIndexTs(contractImport),
@@ -71,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`.',
                     ],
                 },
@@ -91,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/contract.js

@@ -1,4 +1,4 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const CONTRACT_SCRIPTS = [
     'dev',
     'build',
@@ -93,7 +93,7 @@ export const socketConfig = sockets.config
 export const socketEvents = sockets.events
 export type AppRegistry = typeof registry
 `;
-function contractPackageJson(name) {
+function contractPackageJson(name, options) {
     return basePackageJson({
         name,
         private: false,
@@ -104,7 +104,7 @@ function contractPackageJson(name) {
             },
         },
         // ✅ Solution #2: dev continuously emits dist/*.js + dist/*.d.ts
-        scripts: baseScripts('tsc -p tsconfig.json --watch --preserveWatchOutput'),
+        scripts: baseScripts('tsc -p tsconfig.json --watch --preserveWatchOutput', undefined, { includePrepare: options?.includePrepare }),
         // You can keep this pinned if you want, but the import strategy above prevents breakage
         // across different module export shapes.
         dependencies: {
@@ -117,9 +117,13 @@ function contractPackageJson(name) {
     });
 }
 async function contractFiles(pkgName, targetDir) {
-    const tsconfig = await packageTsConfig(targetDir);
+    const includePrepare = isWorkspaceRoot(targetDir);
+    const tsconfig = await packageTsConfig(targetDir, {
+        include: ['src/**/*.ts', 'src/**/*.tsx'],
+        skipLibCheck: true,
+    });
     return {
-        'package.json': contractPackageJson(pkgName),
+        'package.json': contractPackageJson(pkgName, { includePrepare }),
         'tsconfig.json': tsconfig,
         ...basePackageFiles(),
         'src/index.ts': CONTRACT_TS,

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

@@ -1,4 +1,4 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const DOCKER_SCRIPTS = [
     'dev',
     'build',
@@ -18,7 +18,7 @@ const DOCKER_SCRIPTS = [
     'docker:clean',
     'docker:reset',
 ];
-function dockerPackageJson(name) {
+function dockerPackageJson(name, options) {
     return basePackageJson({
         name,
         scripts: baseScripts('tsx watch src/index.ts', {
@@ -31,7 +31,7 @@ function dockerPackageJson(name) {
             'docker:stop': 'npm run docker:cli -- stop',
             'docker:clean': 'npm run docker:cli -- clean',
             'docker:reset': 'npm run docker:cli -- reset',
-        }),
+        }, { includePrepare: options?.includePrepare }),
         dependencies: {
             cors: '^2.8.5',
             express: '^5.1.0',
@@ -96,9 +96,13 @@ CMD ["node", "dist/index.js"]
 `;
 }
 async function dockerFiles(pkgName, targetDir) {
-    const tsconfig = await packageTsConfig(targetDir, { types: ['node'] });
+    const includePrepare = isWorkspaceRoot(targetDir);
+    const tsconfig = await packageTsConfig(targetDir, {
+        include: ['src/**/*.ts'],
+        types: ['node'],
+    });
     return {
-        'package.json': dockerPackageJson(pkgName),
+        'package.json': dockerPackageJson(pkgName, { includePrepare }),
         'tsconfig.json': tsconfig,
         'src/index.ts': dockerIndexTs(),
         'scripts/docker.ts': dockerCliScript(pkgName),

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

@@ -1,4 +1,4 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const EMPTY_SCRIPTS = [
     'dev',
     'build',
@@ -10,19 +10,26 @@ const EMPTY_SCRIPTS = [
     'clean',
     'test',
 ];
-function emptyPackageJson(name) {
+function emptyPackageJson(name, options) {
     return basePackageJson({
         name,
-        scripts: baseScripts('tsx watch src/index.ts'),
+        scripts: baseScripts('tsx watch src/index.ts', undefined, {
+            includePrepare: options?.includePrepare,
+        }),
         devDependencies: {
             ...BASE_LINT_DEV_DEPENDENCIES,
         },
     });
 }
 async function emptyFiles(pkgName, targetDir) {
-    const tsconfig = await packageTsConfig(targetDir, { types: ['node'] });
+    const includePrepare = isWorkspaceRoot(targetDir);
+    const tsconfig = await packageTsConfig(targetDir, {
+        include: ['src/**/*.ts', 'src/**/*.tsx'],
+        types: ['node'],
+        skipLibCheck: true,
+    });
     return {
-        'package.json': emptyPackageJson(pkgName),
+        'package.json': emptyPackageJson(pkgName, { includePrepare }),
         'tsconfig.json': tsconfig,
         ...basePackageFiles(),
         'src/index.ts': "export const hello = 'world'\n",

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

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, baseTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, writeFileIfMissing, } from '../shared.js';
 import { clientVariant } from './client.js';
 import { serverVariant } from './server.js';
 import { dockerVariant } from './docker.js';
@@ -43,6 +43,9 @@ function deriveDirs(rootDir, baseName) {
         docker: path.join(packagesRoot, `${baseName}-docker`),
     };
 }
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
 function rootPackageJson(baseName) {
     const dockerPackageDir = `packages/${baseName}-docker`;
     return basePackageJson({
@@ -50,7 +53,7 @@ function rootPackageJson(baseName) {
         private: true,
         useDefaults: false,
         scripts: {
-            setup: 'pnpm install && pnpm exec husky install',
+            setup: 'pnpm install && (git rev-parse --is-inside-work-tree >/dev/null 2>&1 && pnpm exec husky || true)',
             dev: 'pnpm -r dev --parallel --if-present',
             build: 'pnpm -r build',
             typecheck: 'pnpm -r typecheck',
@@ -61,7 +64,7 @@ function rootPackageJson(baseName) {
             'format:check': 'pnpm -r format:check --if-present',
             test: 'pnpm -r test --if-present',
             clean: 'pnpm -r clean --if-present && rimraf node_modules .turbo coverage',
-            prepare: 'husky install || true',
+            prepare: 'git rev-parse --is-inside-work-tree >/dev/null 2>&1 && husky || true',
             'docker:up': `pnpm -C ${dockerPackageDir} run docker:up`,
             'docker:dev': `pnpm -C ${dockerPackageDir} run docker:dev`,
             'docker:logs': `pnpm -C ${dockerPackageDir} run docker:logs`,
@@ -77,6 +80,50 @@ function rootPackageJson(baseName) {
 function rootPnpmWorkspace() {
     return "packages:\n  - 'packages/*'\n";
 }
+function rootTsconfigBase(baseName, names) {
+    const paths = {
+        [names.contract]: [`packages/${baseName}-contract/src`],
+        [`${names.contract}/*`]: [`packages/${baseName}-contract/src/*`],
+        [names.server]: [`packages/${baseName}-server/src`],
+        [`${names.server}/*`]: [`packages/${baseName}-server/src/*`],
+        [names.client]: [`packages/${baseName}-client/src`],
+        [`${names.client}/*`]: [`packages/${baseName}-client/src/*`],
+        [names.docker]: [`packages/${baseName}-docker/src`],
+        [`${names.docker}/*`]: [`packages/${baseName}-docker/src/*`],
+    };
+    const config = {
+        $schema: 'https://json.schemastore.org/tsconfig',
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'ESNext',
+            moduleResolution: 'Bundler',
+            jsx: 'react-jsx',
+            strict: true,
+            skipLibCheck: true,
+            resolveJsonModule: true,
+            forceConsistentCasingInFileNames: true,
+            sourceMap: true,
+            baseUrl: '.',
+            paths,
+        },
+    };
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+function rootSolutionTsconfig(dirs) {
+    const references = [
+        dirs.contract,
+        dirs.server,
+        dirs.client,
+        dirs.docker,
+    ].map((pkgDir) => ({ path: toPosixPath(path.relative(dirs.root, pkgDir)) }));
+    const config = {
+        $schema: 'https://json.schemastore.org/tsconfig',
+        extends: './tsconfig.base.json',
+        files: [],
+        references,
+    };
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
 function stackComposeYaml() {
     return `services:
   db:
@@ -95,16 +142,13 @@ volumes:
   db-data:
 `;
 }
-async function scaffoldRootFiles(baseDir, baseName) {
+async function scaffoldRootFiles(baseDir, baseName, names, dirs) {
     const files = {
         'package.json': rootPackageJson(baseName),
         'pnpm-workspace.yaml': rootPnpmWorkspace(),
         'docker-compose.yml': stackComposeYaml(),
-        'tsconfig.json': baseTsConfig({
-            rootDir: '.',
-            outDir: 'dist',
-            include: ['packages/**/*', 'scripts/**/*', 'src/**/*'],
-        }),
+        'tsconfig.base.json': rootTsconfigBase(baseName, names),
+        'tsconfig.json': rootSolutionTsconfig(dirs),
         ...basePackageFiles(),
     };
     for (const [relative, contents] of Object.entries(files)) {
@@ -136,7 +180,7 @@ export const fullstackVariant = {
         const names = deriveNames(baseName);
         const dirs = deriveDirs(ctx.targetDir, baseName);
         // Root workspace files
-        await scaffoldRootFiles(dirs.root, baseName);
+        await scaffoldRootFiles(dirs.root, baseName, names, dirs);
         // Contract package (reuse contract variant)
         await contractVariant.scaffold({
             targetDir: dirs.contract,

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

@@ -1,4 +1,4 @@
-import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, writeFileIfMissing, } from '../shared.js';
+import { BASE_LINT_DEV_DEPENDENCIES, basePackageFiles, basePackageJson, buildReadme, baseScripts, packageTsConfig, isWorkspaceRoot, writeFileIfMissing, } from '../shared.js';
 const SERVER_SCRIPTS = [
     'dev',
     'build',
@@ -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) {
+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',
-        }),
-        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',
-        },
+        }, { includePrepare: options?.includePrepare }),
+        dependencies,
         devDependencies: {
             ...BASE_LINT_DEV_DEPENDENCIES,
             '@types/cors': '^2.8.5',
@@ -82,9 +90,13 @@ export function serverPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLD
     });
 }
 async function serverFiles(pkgName, contractImport, targetDir) {
-    const tsconfig = await packageTsConfig(targetDir, { types: ['node'] });
+    const includePrepare = isWorkspaceRoot(targetDir);
+    const tsconfig = await packageTsConfig(targetDir, {
+        include: ['src/**/*.ts'],
+        types: ['node'],
+    });
     return {
-        'package.json': serverPackageJson(pkgName, contractImport),
+        'package.json': serverPackageJson(pkgName, contractImport, { includePrepare }),
         'tsconfig.json': tsconfig,
         ...basePackageFiles(),
         'src/index.ts': serverIndexTs(contractImport),
@@ -106,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.',
                     ],
                 },
@@ -126,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/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/publish.js

@@ -134,7 +134,7 @@ 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;
         if (!parsed.selectionArg) {
@@ -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.5",
+  "version": "0.5.0",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",
@@ -30,8 +30,7 @@
   "devDependencies": {
     "@types/node": "^20.17.0",
     "@types/semver": "^7.7.1",
-    "cross-env": "^7.0.3",
-    "@emeryld/manager": "^0.4.1"
+    "cross-env": "^7.0.3"
   },
   "ts-node": {
     "esm": true,