@rtorcato/repo-tooling 3.8.5 → 3.8.7

package/dist/base/checks.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import fs from 'fs-extra';
+import { BLOCK_START, hasStaleAgentBlock } from '../cli/generators/agent-rules.js';
 import { BADGE_START, hasPublicOnlyBadges } from '../cli/generators/badges.js';
 import { detectNestedLanguages } from '../cli/utils/detect-language.js';
 /**
@@ -335,19 +336,37 @@ export async function checkCoverageUpload(dir) {
     };
 }
 export async function checkAiSetup(dir) {
-    // Consider AI setup present if AGENTS.md carries the js-tooling block or the
-    // Claude skill is installed — the two primary markers `fix ai` writes.
-    const agentsPath = path.join(dir, 'AGENTS.md');
-    const hasAgentsBlock = (await fs.pathExists(agentsPath)) &&
-        (await fs.readFile(agentsPath, 'utf8')).includes('<!-- js-tooling:start -->');
+    // Consider AI setup present if one of the block-managed files carries the
+    // agent block or the Claude skill is installed — the markers `fix ai` writes.
+    let blockFile = null;
+    const stale = [];
+    for (const rel of ['AGENTS.md', 'CLAUDE.md', path.join('.github', 'copilot-instructions.md')]) {
+        const filepath = path.join(dir, rel);
+        if (!(await fs.pathExists(filepath)))
+            continue;
+        const content = await fs.readFile(filepath, 'utf8');
+        if (!content.includes(BLOCK_START))
+            continue;
+        blockFile ??= rel;
+        if (hasStaleAgentBlock(content))
+            stale.push(rel);
+    }
     const hasSkill = (await fs.pathExists(path.join(dir, '.claude', 'skills', 'repo-tooling.md'))) ||
         // Pre-rename name — still counts as present until `fix` migrates it.
         (await fs.pathExists(path.join(dir, '.claude', 'skills', 'js-tooling.md')));
-    if (hasAgentsBlock || hasSkill) {
+    if (stale.length > 0) {
+        return {
+            check: 'AI setup',
+            status: 'drift',
+            detail: `${stale.join(', ')} still point agents at the dead \`js-tooling\` package/bin`,
+            hint: 'Run `npx @rtorcato/repo-tooling fix ai` to refresh the agent instructions in place',
+        };
+    }
+    if (blockFile || hasSkill) {
         return {
             check: 'AI setup',
             status: 'ok',
-            detail: hasAgentsBlock ? 'AGENTS.md has the js-tooling block' : '.claude skill installed',
+            detail: blockFile ? `${blockFile} has the agent block` : '.claude skill installed',
         };
     }
     return {

package/dist/base/github-settings.js

@@ -352,6 +352,14 @@ const PROTECTION_BODY = JSON.stringify({
     // enforce_admins off so the App/RELEASE_TOKEN can bypass to push release commits.
     enforce_admins: false,
     // Required human review would deadlock solo Dependabot auto-merge.
+    //
+    // Note this is *applied*, not merely tolerated: checkBranchProtection reports
+    // any required_pull_request_reviews as drift, so `fix github-settings` PUTs it
+    // back to null. A repo that deliberately requires approvals will have that
+    // silently reverted by the next unrelated fix run, with nothing in the output
+    // naming the rule that was removed. Known downstream case: the ai-issue-loop
+    // pipeline works around it with approval labels precisely because of this.
+    // Loosen the standard here first if a repo ever genuinely needs review gating.
     required_pull_request_reviews: null,
     restrictions: null,
     allow_force_pushes: false,

package/dist/cli/generators/agent-rules.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { copyPreset, getPackageRoot } from '../utils/copy-preset.js';
+import { LEGACY_TOOL_NAME } from '../utils/lockfile.js';
 import { installSkillsInstallDocs } from './skills-install.js';
 /**
  * All agent rule files are generated from one source of truth — the shipped
@@ -8,8 +9,25 @@ import { installSkillsInstallDocs } from './skills-install.js';
  * location and the frontmatter differ per agent.
  */
 const SOURCE = 'tooling/claude/repo-tooling.md';
-const BLOCK_START = '<!-- js-tooling:start -->';
-const BLOCK_END = '<!-- js-tooling:end -->';
+// The markers keep the pre-rename text on purpose: changing them would orphan
+// every block already written and append a second one on the next fix.
+export const BLOCK_START = '<!-- js-tooling:start -->';
+export const BLOCK_END = '<!-- js-tooling:end -->';
+/**
+ * True when a managed block still names the pre-rename package or bin — a repo
+ * scaffolded before the rename tells agents to run `js-tooling fix ai`, which
+ * is not a runnable command (#393). Only the block *body* is inspected: the
+ * markers carry the legacy name by design, so matching on the whole file would
+ * report every repo as permanently stale.
+ */
+export function hasStaleAgentBlock(content) {
+    const start = content.indexOf(BLOCK_START);
+    if (start === -1)
+        return false;
+    const bodyStart = start + BLOCK_START.length;
+    const end = content.indexOf(BLOCK_END, bodyStart);
+    return content.slice(bodyStart, end === -1 ? undefined : end).includes(LEGACY_TOOL_NAME);
+}
 /** Read the shipped skill and split its frontmatter from the markdown body. */
 async function readSkill() {
     const raw = await fs.readFile(path.join(getPackageRoot(), SOURCE), 'utf8');

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/cli/utils/lockfile.js

@@ -3,10 +3,14 @@ import fs from 'fs-extra';
 import packageJson from '../../../package.json' with { type: 'json' };
 import { validateProjectConfig } from '../commands/setup-presets.js';
 export const LOCKFILE_NAME = '.repo-tooling.json';
-// Name used before the js-tooling→repo-tooling rename (#272). Repos set up on an
-// older version still have it: readLockfile falls back to it, and writeLockfile
-// migrates to the new name (removing the old file) on the next write.
-export const LEGACY_LOCKFILE_NAME = '.js-tooling.json';
+// Package and bin name used before the js-tooling→repo-tooling rename (#272).
+// The bin no longer exists and the package is 404 on the registry, so any
+// generated file still naming it is stale (#393).
+export const LEGACY_TOOL_NAME = 'js-tooling';
+// Lockfile name from the same era. Repos set up on an older version still have
+// it: readLockfile falls back to it, and writeLockfile migrates to the new name
+// (removing the old file) on the next write.
+export const LEGACY_LOCKFILE_NAME = `.${LEGACY_TOOL_NAME}.json`;
 // v2 added ProjectConfig.language (multi-language seam, #140). v1 files are
 // migrated to v2 on read, defaulting language to 'js'.
 export const LOCKFILE_VERSION = 2;

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.7",
 	"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') },
-			],
-		},
 	})
 )