@rtorcato/repo-tooling 3.8.5 → 3.8.6

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/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

@@ -427,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] };
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rtorcato/repo-tooling",
-	"version": "3.8.5",
+	"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') },
-			],
-		},
 	})
 )