@emeryld/manager 0.4.5 → 0.4.6

package/dist/create-package/index.js

@@ -4,7 +4,7 @@ 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 { 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';
@@ -383,6 +383,8 @@ async function gatherTarget(initial = {}) {
 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',
@@ -29,10 +29,12 @@ export const healthGet = routeClient.build(registry.byKey['GET /api/health'])
 export const healthPost = routeClient.build(registry.byKey['POST /api/health'])
 `;
 }
-export function clientPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER) {
+export function clientPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER, options) {
     return basePackageJson({
         name,
-        scripts: baseScripts('tsx watch src/index.ts'),
+        scripts: baseScripts('tsx watch src/index.ts', undefined, {
+            includePrepare: options?.includePrepare,
+        }),
         dependencies: {
             [contractName]: 'workspace:*',
             '@emeryld/rrroutes-client': '^2.5.3',
@@ -46,12 +48,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),

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',
@@ -58,13 +58,13 @@ server.listen(PORT, () => {
 })
 `;
 }
-export function serverPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER) {
+export function serverPackageJson(name, contractName = CONTRACT_IMPORT_PLACEHOLDER, options) {
     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',
@@ -82,9 +82,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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "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,