@rtorcato/repo-tooling 3.8.4 → 3.8.6

package/dist/cli/commands/setup-presets.js

@@ -212,6 +212,10 @@ export function computeFileList(config) {
     if (config.typescript.enabled) {
         files.push('tsconfig.json', 'reset.d.ts');
     }
+    // Libraries get a bundle-size budget plus the `size-limit` script that runs it
+    // (#382). The scaffold's exports are root-only, so it's always the static form.
+    if (config.projectType === 'library')
+        files.push('.size-limit.json');
     if (config.linting.tool === 'biome' || config.linting.tool === 'both') {
         files.push(BIOME_CONFIG);
     }

package/dist/cli/generators/gitlab-ci.js

@@ -2,9 +2,14 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import { renderGitLabCI } from '../../base/ci.js';
 import { gitlabSpec } from '../../languages/js/ci.js';
-export async function generateGitLabCI(config, targetDir) {
+/**
+ * @param scripts The target's package.json scripts, so the pipeline only calls
+ * commands that exist (#386). Omit on the `setup` path, which writes the
+ * scripts itself as part of the same scaffold.
+ */
+export async function generateGitLabCI(config, targetDir, { scripts } = {}) {
     const yamlPath = path.join(targetDir, '.gitlab-ci.yml');
     // ponytail: direct JS import until a second language module ships CI (#287).
-    await fs.writeFile(yamlPath, renderGitLabCI(gitlabSpec(config)));
+    await fs.writeFile(yamlPath, renderGitLabCI(gitlabSpec(config, { scripts })));
     return '.gitlab-ci.yml';
 }

package/dist/cli/generators/index.js

@@ -8,7 +8,7 @@ import { ensurePnpmSettings, familyGlob } from './pnpm-workspace.js';
 import { generateGitConfigs } from './git.js';
 import { generateGitHubActions } from './github-actions.js';
 import { generateLintingConfigs } from './linting.js';
-import { generateKnipConfig, generateMiscBaseline, generateVscodeExtensions } from './misc.js';
+import { generateKnipConfig, generateMiscBaseline, generateSizeLimitConfig, generateVscodeExtensions, } from './misc.js';
 import { generatePackageJson } from './package-json.js';
 import { generateReadme } from './readme.js';
 import { generateSecurityConfigs } from './security.js';
@@ -33,6 +33,12 @@ export async function generateConfigs(config, targetDir) {
     await generatePackageJson(config, targetDir);
     // Universal baseline: .editorconfig, .nvmrc, engines.node, knip.json
     await generateMiscBaseline(targetDir);
+    // Bundle-size budget for publishable libraries. getScripts() emits the
+    // matching `size-limit` script, so the budget is runnable from the first
+    // commit rather than an inert file implying enforcement (#382).
+    if (config.projectType === 'library') {
+        await generateSizeLimitConfig(targetDir);
+    }
     // Recommend the editor extensions matching the enabled tools
     await generateVscodeExtensions(config, targetDir);
     // Generate TypeScript configuration

package/dist/cli/generators/package-json.js

@@ -141,6 +141,10 @@ function getScripts(config, opts = {}) {
     // profile fits the dual (cjs+esm) exports the library scaffold emits.
     if (config.projectType === 'library') {
         scripts['attw'] = 'attw --pack';
+        // The budget scaffolded alongside it (generateConfigs) is inert without a
+        // way to run it — a size budget nothing runs implies an enforcement that
+        // isn't there (#382).
+        Object.assign(scripts, SIZE_LIMIT_SCRIPTS);
     }
     // Git hooks
     if (config.gitHooks) {
@@ -169,6 +173,14 @@ function getScripts(config, opts = {}) {
  * refused to compose a chain, both because no target ever created that script
  * (#364).
  */
+/**
+ * The one definition of the `size-limit` script, shared by `getScripts()` (setup)
+ * and the `size-limit` fixer, so the two paths can't drift (#382 — the divergence
+ * behind #371 and #377).
+ */
+export const SIZE_LIMIT_SCRIPTS = { 'size-limit': 'size-limit' };
+/** Shared by the same two paths, for the same reason. */
+export const SIZE_LIMIT_VERSION = '^11.2.0';
 export async function ensureScripts(targetDir, scripts) {
     const pkgPath = path.join(targetDir, 'package.json');
     if (!(await fs.pathExists(pkgPath)))
@@ -352,8 +364,11 @@ function getDependencies(config) {
         deps['lint-staged'] = '^16.0.0';
     }
     // are-the-types-wrong — validate published type resolution for libraries.
+    // size-limit enforces the bundle-size budget scaffolded next to it; without
+    // the dependency the script dies with "command not found" (#382).
     if (config.projectType === 'library') {
         deps['@arethetypeswrong/cli'] = '^0.18.2';
+        deps['size-limit'] = SIZE_LIMIT_VERSION;
     }
     // Commit linting (enforcement) + commitizen (assistance)
     if (config.commitLint) {

package/dist/cli/generators/testing.js

@@ -22,25 +22,27 @@ export async function generateVitestConfig(config, targetDir) {
     // `oxc` (not `esbuild`) is the Vite 8 spelling — vitest ^4 resolves Vite 8,
     // and Vite 8 silently ignores the old `esbuild` key.
     const jsxOverride = config.projectType === 'nextjs-app'
-        ? `  // tsconfig sets jsx: "preserve" for Next's compiler; vitest needs a
-  // transform of its own or .tsx tests won't parse.
-  oxc: { jsx: { runtime: 'automatic' } },
+        ? `    // tsconfig sets jsx: "preserve" for Next's compiler; vitest needs a
+    // transform of its own or .tsx tests won't parse.
+    oxc: { jsx: { runtime: 'automatic' } },
 `
         : '';
-    const vitestConfig = `import { defineConfig } from 'vitest/config'
+    // Layered on the shipped preset rather than hand-rolled: the preset owns
+    // globals, the shared excludes and the v8/lcov coverage reporters, so preset
+    // improvements reach consumers — and doctor's `Vitest` check (which looks for
+    // this import) can actually pass after `fix vitest` (#387).
+    const vitestConfig = `import base from '@rtorcato/repo-tooling/vitest/config'
+import { defineConfig, mergeConfig } from 'vitest/config'
 
-export default defineConfig({
-${jsxOverride}  test: {
-    globals: true,
-    environment: '${config.testing.environment === 'browser' ? 'jsdom' : 'node'}',
-    setupFiles: ['./vitest.setup.ts'],
-    coverage: {
-      provider: 'v8',
-      // lcov feeds Codecov; text is the local console summary.
-      reporter: ['text', 'lcov']
+export default mergeConfig(
+  base,
+  defineConfig({
+${jsxOverride}    test: {
+      environment: '${config.testing.environment === 'browser' ? 'jsdom' : 'node'}',
+      setupFiles: ['./vitest.setup.ts']
     }
-  }
-})
+  })
+)
 `;
     await fs.writeFile(vitestConfigPath, vitestConfig);
     // Create setup file

package/dist/languages/js/checks.js

@@ -89,14 +89,74 @@ function matchesBiomeConfig(contents) {
         schema.includes('biomejs.dev/schemas/') &&
         linter?.rules?.preset !== undefined);
 }
+const TS_PRESET_REF = /@rtorcato\/(?:js|repo)-tooling\/typescript\//;
+/**
+ * Options `tooling/typescript/tsconfig.base.json` sets that a tsconfig written
+ * by hand is unlikely to carry all of. `strict` alone is far too common to
+ * conclude anything from.
+ */
+const TS_PRESET_STRICTNESS = [
+    'strict',
+    'noUncheckedIndexedAccess',
+    'noImplicitOverride',
+    'noPropertyAccessFromIndexSignature',
+];
+/**
+ * `strict` and every flag it implies. TypeScript lets any one of these be
+ * switched off individually while `strict: true` is still literally present —
+ * the explicit override wins — so a config can keep every marker this check
+ * looks for and still ship with type safety off. Any of them explicitly
+ * `false` is drift.
+ */
+const TS_STRICT_FLAGS = [
+    'strict',
+    'noImplicitAny',
+    'strictNullChecks',
+    'strictFunctionTypes',
+    'strictBindCallApply',
+    'strictPropertyInitialization',
+    'noImplicitThis',
+    'useUnknownInCatchVariables',
+    'alwaysStrict',
+];
+/**
+ * The same two shapes as `matchesBiomeConfig`, for the same reason (#385): the
+ * `extends` pointer `fix tsconfig` writes, and the whole preset inlined, which
+ * is what `copy tsconfig` drops — `tooling/typescript/tsconfig.base.json` *is*
+ * the preset, so it names it nowhere, and every `copy tsconfig` repo was
+ * reported as drifted with no way out. This check isn't optional, so that read
+ * as a real problem rather than an optional one.
+ *
+ * Structural rather than textual, and for the same reason: `strict: false` is
+ * drift whichever shape the config takes, a marker sitting in a comment proves
+ * nothing, and unparseable counts as drift rather than being waved through.
+ */
+function matchesTsConfig(contents) {
+    const config = parseJsonc(contents);
+    if (!config)
+        return false;
+    const compilerOptions = (config.compilerOptions ?? {});
+    // Naming the preset and then switching strictness off is precisely the drift
+    // this check exists to catch, so it disqualifies either shape — `strict`
+    // itself or any single flag it implies.
+    if (TS_STRICT_FLAGS.some((key) => compilerOptions[key] === false))
+        return false;
+    if (TS_PRESET_REF.test(JSON.stringify(config.extends ?? '')))
+        return true;
+    // The inlined preset: a `${configDir}`-anchored rootDir — how a preset meant
+    // to be extended resolves against the consuming repo — plus the strict block
+    // the shipped preset sets.
+    const rootDir = compilerOptions.rootDir;
+    return (typeof rootDir === 'string' &&
+        rootDir.includes('${configDir}') &&
+        TS_PRESET_STRICTNESS.every((key) => compilerOptions[key] === true));
+}
 export const FILE_CHECKS = [
     {
         check: 'TypeScript',
         candidates: ['tsconfig.json'],
-        expected: `extends "${PACKAGE}/typescript/*"`,
-        matcher: /@rtorcato\/(?:js|repo)-tooling\/typescript\//,
-        // `fix tsconfig`, not `copy tsconfig`: copy drops the whole preset inline,
-        // which carries no `extends` for the matcher above to find (#381).
+        expected: `extends "${PACKAGE}/typescript/*" or inlines the preset, with strict on`,
+        matcher: matchesTsConfig,
         hint: 'Run `npx @rtorcato/repo-tooling fix tsconfig` to scaffold',
     },
     {

package/dist/languages/js/ci.js

@@ -74,9 +74,13 @@ export function scriptsOf(pkg) {
         return undefined;
     return pkg.scripts ?? {};
 }
+/** The repo defines this script — or we have no scripts to check it against. */
+function hasScript(opts, script) {
+    return !opts.scripts || script in opts.scripts;
+}
 /** Emit a step only when the script it runs exists (or we can't know yet). */
 function stepFor(opts, script, step) {
-    return !opts.scripts || script in opts.scripts ? step : null;
+    return hasScript(opts, script) ? step : null;
 }
 /** Join the steps that survived gating onto the shared setup preamble. */
 function jobSteps(steps) {
@@ -212,17 +216,33 @@ ${attw}${publint}
     }
     return jobs;
 }
-/** The `.gitlab-ci.yml` spec for a JS repo — node image, pnpm store cache, pnpm scripts. */
-export function gitlabSpec(config) {
+/**
+ * The `.gitlab-ci.yml` spec for a JS repo — node image, pnpm store cache, pnpm
+ * scripts. `opts.scripts` gates each job on the script it runs exactly as
+ * `githubJobs` does (#386): `fix gitlab-ci` renders for a repo that already
+ * exists and may have none of them, and a job calling a missing script dies
+ * with ERR_PNPM_RECURSIVE_EXEC. Undefined still means "assume the setup shape".
+ *
+ * Dropping the `build` job takes its `artifacts` block with it; no other job
+ * references that artifact, so the pipeline stays coherent without it.
+ */
+export function gitlabSpec(config, opts = {}) {
     const hasTypeScript = config.typescript.enabled;
     const hasTests = config.testing.framework !== 'none';
     const hasLint = config.linting.tool !== 'none';
     const hasBuild = config.bundler !== 'none';
+    const test = gitlabTest(config);
     const jobs = [
-        ...(hasLint ? [{ id: 'lint', stage: 'test', script: [lintCommand(config)] }] : []),
-        ...(hasTypeScript ? [{ id: 'typecheck', stage: 'test', script: ['pnpm typecheck'] }] : []),
-        ...(hasTests ? [{ id: 'test', stage: 'test', script: [gitlabTestCommand(config)] }] : []),
-        ...(hasBuild
+        ...(hasLint && hasScript(opts, lintScript(config))
+            ? [{ id: 'lint', stage: 'test', script: [lintCommand(config)] }]
+            : []),
+        ...(hasTypeScript && hasScript(opts, 'typecheck')
+            ? [{ id: 'typecheck', stage: 'test', script: ['pnpm typecheck'] }]
+            : []),
+        ...(hasTests && (test.script === null || hasScript(opts, test.script))
+            ? [{ id: 'test', stage: 'test', script: [test.command] }]
+            : []),
+        ...(hasBuild && hasScript(opts, 'build')
             ? [
                 {
                     id: 'build',
@@ -258,10 +278,16 @@ default:
         jobs,
     };
 }
-function gitlabTestCommand(config) {
+/**
+ * The GitLab test command, paired with the package.json script it needs.
+ * Vitest is invoked through `pnpm exec` — a direct binary call, so `script` is
+ * null and the job is never gated away; the other frameworks run a script that
+ * has to exist.
+ */
+function gitlabTest(config) {
     if (config.testing.framework === 'vitest')
-        return 'pnpm exec vitest run';
+        return { command: 'pnpm exec vitest run', script: null };
     if (config.testing.framework === 'playwright' || config.testing.framework === 'cypress')
-        return 'pnpm test:e2e';
-    return 'pnpm test';
+        return { command: 'pnpm test:e2e', script: 'test:e2e' };
+    return { command: 'pnpm test', script: 'test' };
 }

package/dist/languages/js/fixers.js

@@ -11,7 +11,7 @@ import { BIOME_CONFIG, generateBiomeConfig, generateESLintConfig, generatePretti
 import { alignNodeVersion, ensureEnginesNode, ensurePackageManager, generateKnipConfig, generateNvmrc, generateSizeLimitConfig, generateVscodeExtensions, } from '../../cli/generators/misc.js';
 import { scriptsOf } from './ci.js';
 import { usesPnpm } from './checks.js';
-import { composeVerifyScriptFromPkg, ensureScripts } from '../../cli/generators/package-json.js';
+import { SIZE_LIMIT_SCRIPTS, SIZE_LIMIT_VERSION, composeVerifyScriptFromPkg, ensureScripts, } from '../../cli/generators/package-json.js';
 /** Kept in step with the biome branch of getScripts() in package-json.ts. */
 const BIOME_SCRIPTS = {
     lint: 'biome lint .',
@@ -32,6 +32,24 @@ const PRETTIER_SCRIPTS = {
 const KNIP_SCRIPTS = {
     knip: 'knip',
 };
+/**
+ * Add `size-limit` to devDependencies unless the repo already pins it (either
+ * dependency list). Returns true when package.json was written.
+ */
+async function ensureSizeLimitDependency(targetDir) {
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (!(await fs.pathExists(pkgPath)))
+        return false;
+    const pkg = (await fs.readJson(pkgPath));
+    const deps = pkg.dependencies ?? {};
+    const devDeps = { ...(pkg.devDependencies ?? {}) };
+    if (devDeps['size-limit'] || deps['size-limit'])
+        return false;
+    devDeps['size-limit'] = SIZE_LIMIT_VERSION;
+    pkg.devDependencies = devDeps;
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+    return true;
+}
 /** Kept in step with the typescript branch of getScripts() in package-json.ts. */
 const TSCONFIG_SCRIPTS = {
     typecheck: 'tsc --noEmit',
@@ -409,7 +427,10 @@ export const FIXERS = [
         outputs: ['.gitlab-ci.yml'],
         canFixDrift: true,
         async run({ targetDir, pkg }) {
-            const written = await generateGitLabCI(inferProjectConfig(pkg), targetDir);
+            // Only reference scripts this repo actually has (#386).
+            const written = await generateGitLabCI(inferProjectConfig(pkg), targetDir, {
+                scripts: scriptsOf(pkg),
+            });
             return { filesWritten: [written] };
         },
     },
@@ -555,13 +576,23 @@ export const FIXERS = [
     },
     {
         target: 'size-limit',
-        description: 'Scaffold a size-limit budget — exports-driven .size-limit.cjs for multi-subpath libraries, else a static .size-limit.json',
+        description: 'Scaffold a size-limit budget — exports-driven .size-limit.cjs for multi-subpath libraries, else a static .size-limit.json — plus the `size-limit` script and devDependency',
         appliesTo: ['size-limit'],
-        outputs: ['.size-limit.cjs', '.size-limit.json'],
+        outputs: ['.size-limit.cjs', '.size-limit.json', 'package.json (devDependencies + scripts)'],
+        // safe-merge: installs the CLI and only fills in a missing script.
+        riskLevel: 'safe-merge',
         canFixDrift: true,
         async run({ targetDir }) {
             const written = await generateSizeLimitConfig(targetDir);
-            return { filesWritten: [written] };
+            const filesWritten = [written];
+            // A budget with nothing to run it is worse than no budget — the file's
+            // presence implies an enforcement that isn't there (#382). The script
+            // needs the CLI installed too, or it dies with "command not found".
+            const installed = await ensureSizeLimitDependency(targetDir);
+            const scripted = await ensureScripts(targetDir, SIZE_LIMIT_SCRIPTS);
+            if (installed || scripted)
+                filesWritten.push('package.json');
+            return { filesWritten };
         },
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rtorcato/repo-tooling",
-	"version": "3.8.4",
+	"version": "3.8.6",
 	"description": "One CLI to scaffold, audit and fix your repo's whole toolchain — linting, tests, commits, releases & CI.",
 	"type": "module",
 	"keywords": [

package/tooling/vitest/vitest.config.d.mts

@@ -1,4 +1,7 @@
-import type { UserConfig } from 'vitest/config'
+// vitest 4 re-exports vite's UserConfig under the name ViteUserConfig; there is
+// no `UserConfig` export on 'vitest/config'. Generated configs import this
+// preset now, so a wrong name here surfaces in every consumer's `tsc --noEmit`.
+import type { ViteUserConfig } from 'vitest/config'
 
-declare const config: UserConfig
+declare const config: ViteUserConfig
 export default config

package/tooling/vitest/vitest.config.mjs

@@ -1,9 +1,10 @@
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { configDefaults, defineConfig } from 'vitest/config'
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
+// No `resolve.alias` here on purpose: this file's `__dirname` is wherever the
+// package got installed, so a `@` → `<preset dir>/src` alias resolves to a
+// directory that exists in no consumer (nor in the published tarball). Now that
+// generated configs actually import this preset, that alias would poison them.
+// Consumers that want `@`/`~` declare them in their own config.
 export default defineConfig({
 	test: {
 		globals: true,
@@ -13,13 +14,9 @@ export default defineConfig({
 		exclude: [...configDefaults.exclude, '.claude/**'],
 		coverage: {
 			provider: 'v8',
-			reporter: ['text', 'json', 'html', 'json-summary'],
+			// lcov feeds Codecov (the CI we generate uploads it); text is the local
+			// console summary; the rest back the HTML report.
+			reporter: ['text', 'lcov', 'json', 'html', 'json-summary'],
 		},
 	},
-	resolve: {
-		alias: [
-			{ find: '@', replacement: resolve(__dirname, './src') },
-			{ find: '~', replacement: resolve(__dirname, './src') },
-		],
-	},
 })

package/tooling/vitest/vitest.config.react.d.mts

@@ -1,4 +1,4 @@
-import type { UserConfig } from 'vitest/config'
+import type { ViteUserConfig } from 'vitest/config'
 
-declare const config: UserConfig
+declare const config: ViteUserConfig
 export default config

package/tooling/vitest/vitest.config.react.mjs

@@ -1,11 +1,9 @@
 import base from '@rtorcato/repo-tooling/vitest/config'
 import react from '@vitejs/plugin-react'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
 import { defineConfig, mergeConfig } from 'vitest/config'
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
+// Same reason as the base preset: an alias built from this file's `__dirname`
+// points inside node_modules, never at the consumer's `src`.
 export default mergeConfig(
 	base,
 	defineConfig({
@@ -17,11 +15,5 @@ export default mergeConfig(
 			exclude: ['OLD/**'],
 			setupFiles: ['./vitest.setup.ts'],
 		},
-		resolve: {
-			alias: [
-				{ find: '@', replacement: resolve(__dirname, './src') },
-				{ find: '~', replacement: resolve(__dirname, './src') },
-			],
-		},
 	})
 )