@rtorcato/repo-tooling 3.31.2 → 3.33.0

package/dist/cli/commands/doctor.js

@@ -232,9 +232,11 @@ async function runBaseChecks(dir, lock, opts) {
     results.push(await checkAiSetup(dir));
     // User-global, not repo state — see checkClaudeSkills on why it never returns drift.
     results.push(await checkClaudeSkills(opts.skillsDir));
-    // #533: gated on `aiLoop`, which is already the "this repo uses the pipeline"
+    // #533: gated on `aiLoop.agentUser`, which is the "this repo uses the pipeline"
     // signal, so a repo that doesn't gets no line at all rather than an empty one.
-    if (lock?.rules?.aiLoop && lock.rules.requiredSkills?.length) {
+    // The key itself no longer says that — since #571 every repo is scaffolded with
+    // an empty `aiLoop`, and the skills have always read the login, not the key.
+    if (lock?.rules?.aiLoop?.agentUser && lock.rules.requiredSkills?.length) {
         results.push(await checkRequiredSkills(lock.rules.requiredSkills, opts.skillsDir));
     }
     // #534: advisory. Absent `mcp.recommended` means the repo has nothing to say

package/dist/cli/commands/fix-targets.js

@@ -76,6 +76,8 @@ const SWIFT_FIX_TARGETS = {
     // `Swift tests` is deliberately absent: when it fails for the manifest half
     // (no `.testTarget(`) there's nothing to run, and rewriting Package.swift
     // isn't safe. The check's own hint covers both halves.
+    // `Swift targets` too (#575): the repair is either adding a target or
+    // deleting the directory, and only the project knows which.
 };
 /** The same shadowing for the Python module (#290). */
 const PYTHON_FIX_TARGETS = {

package/dist/cli/generators/index.js

@@ -91,7 +91,14 @@ export async function generateConfigs(config, targetDir) {
     await ensureBuildApprovals(config, targetDir);
     // Family-wide pnpm settings (#314). Runs last of the workspace writers so it
     // merges into whatever they wrote rather than racing them for the file.
-    await ensurePnpmSettings(targetDir, bundlerNeedsEsbuild(config), familyGlob(config.projectName));
+    //
+    // The scope is read back off the emitted package.json rather than taken from
+    // config.projectName: under `--preset` that name is only the directory
+    // basename, while generatePackageJson preserves an existing scoped `name`.
+    // doctor derives the glob from that same field, so reading the basename left
+    // the two disagreeing on every scoped repo (#573).
+    const { name } = (await fs.readJson(path.join(targetDir, 'package.json')));
+    await ensurePnpmSettings(targetDir, bundlerNeedsEsbuild(config), familyGlob(name));
     // Turborepo task pipeline (pnpm-workspace monorepos, when opted-in)
     if (config.turborepo) {
         await generateTurborepo(targetDir);

package/dist/cli/generators/pnpm-workspace.js

@@ -24,10 +24,16 @@ export const WORKSPACE_FILE = 'pnpm-workspace.yaml';
  *
  * One glob covers a whole scope: pnpm matches these entries with
  * `@pnpm/config.matcher`, so there's no package list to keep in sync.
+ *
+ * The scope is matched against npm's own name charset, not just "anything up
+ * to the slash": the name comes verbatim from a pre-existing `package.json`
+ * and is never validated as an npm name on the way here, so a scope of a lone
+ * wildcard would otherwise be taken as a glob and exempt every scoped package
+ * from the release-age delay. An unparseable scope gets no setting at all.
  */
 export function familyGlob(packageName) {
     const name = typeof packageName === 'string' ? packageName : '';
-    const scope = /^(@[^/]+)\//.exec(name)?.[1];
+    const scope = /^(@[a-z0-9-][a-z0-9._-]*)\//i.exec(name)?.[1];
     return scope ? `${scope}/*` : null;
 }
 /** Bundlers that pull in esbuild, whose install script pnpm 11 refuses to run unapproved. */

package/dist/cli/utils/lockfile.js

@@ -27,6 +27,21 @@ const LOCKFILE_SCHEMA_URL = 'https://rtorcato.github.io/repo-tooling/schemas/loc
  * branches on it beyond printing it.
  */
 export const MCP_IMPORTANCE = ['nice-to-have', 'important', 'critical'];
+/**
+ * The empty ruleset a repo with no stated rules gets (#571). `rules` used to
+ * appear only via v1–v3 migration, so the repos this tool creates were exactly
+ * the ones with nothing to edit and nothing to compare. Writing the containers
+ * — with `$schema` stamped alongside — makes the file teach its own shape.
+ *
+ * Values, never defaults: every entry is empty, because a populated one would
+ * be this tool asserting a rule on a repo whose humans have not stated any.
+ */
+export const DEFAULT_RULES = {
+    aiLoop: {},
+    requiredSkills: [],
+    mcp: { recommended: [] },
+    exceptions: {},
+};
 /**
  * JSON Schema for the lockfile, published with the docs site at the exact URL
  * every written lockfile's `$schema` points to (#529). The `satisfies` clauses
@@ -246,7 +261,8 @@ export async function writeLockfile(dir, config, assets) {
             writtenBy: `@rtorcato/repo-tooling@${await getToolVersion()}`,
             writtenAt: new Date().toISOString(),
         },
-        ...(existing?.rules ? { rules: existing.rules } : {}),
+        // A repo that has stated no rules gets the empty scaffold, not nothing (#571).
+        rules: existing?.rules ?? DEFAULT_RULES,
     };
     await fs.writeJson(filepath, lockfile, { spaces: 2 });
     // Migrate a pre-rename repo to the new name: now that the canonical file is

package/dist/languages/swift/checks.js

@@ -16,6 +16,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { checkFile } from '../../base/checks.js';
+import { parsePackageSwift } from './ci.js';
 import { SWIFT_HOOKS_DIR } from './git-hooks.js';
 const SWIFT_FILE_CHECKS = [
     {
@@ -118,19 +119,82 @@ export async function checkPackageSwift(dir) {
         detail: `Package.swift declares tools ${toolsVersion} and explicit platforms`,
     };
 }
+/** Subdirectory names of `<dir>/<root>`, or none when that root doesn't exist. */
+async function subdirectories(dir, root) {
+    try {
+        const entries = await fs.readdir(path.join(dir, root), { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Directory names under `Sources/`. For a SwiftPM package these are the target
  * names — a target's sources and its DocC catalogue live in the same folder,
  * so this is where both the check and the `docc` fixer have to look.
  */
 export async function swiftSourceTargets(dir) {
-    try {
-        const entries = await fs.readdir(path.join(dir, 'Sources'), { withFileTypes: true });
-        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    return subdirectories(dir, 'Sources');
+}
+/** Where SwiftPM looks for a target's sources when the manifest gives no `path:`. */
+const TARGET_ROOTS = ['Sources', 'Tests'];
+/**
+ * Sources that belong to no declared target (#575). SwiftPM silently ignores a
+ * directory under `Sources/` that no `.target(` names — so `swift build` and
+ * `swift test` both exit 0 while the code in it is never compiled and the tests
+ * in it are never run. There is no red X anywhere, which is the whole reason
+ * this check exists: a renamed target, a dropped `.target(...)` line, or a
+ * generator that rewrote the manifest all leave the same invisible hole.
+ *
+ * No fixer: repairing it means either adding a target or deleting the
+ * directory, and nothing outside the project can tell which.
+ */
+export async function checkSwiftTargets(dir) {
+    const check = 'Swift targets';
+    const filepath = path.join(dir, 'Package.swift');
+    if (!(await fs.pathExists(filepath))) {
+        return { check, status: 'missing', detail: 'no Package.swift' };
     }
-    catch {
-        return [];
+    const contents = await fs.readFile(filepath, 'utf-8');
+    // A custom `path:` puts a target's sources anywhere, so directory names stop
+    // meaning target names and every comparison below becomes a guess. Bail out
+    // rather than report something we can't stand behind. Deliberately crude:
+    // `.package(path:)` for a local dependency trips this too, which costs a
+    // skipped check on repos that use one — cheaper than a false accusation.
+    if (/\bpath:\s*"/.test(contents)) {
+        return {
+            check,
+            status: 'ok',
+            detail: 'not checked — Package.swift uses a custom `path:`, so directories need not match targets',
+        };
     }
+    const declared = new Set(parsePackageSwift(contents).targets);
+    const orphans = [];
+    let scanned = 0;
+    for (const root of TARGET_ROOTS) {
+        for (const name of await subdirectories(dir, root)) {
+            scanned++;
+            if (!declared.has(name))
+                orphans.push(`${root}/${name}`);
+        }
+    }
+    if (scanned === 0) {
+        return { check, status: 'ok', detail: 'no directories under Sources/ or Tests/' };
+    }
+    if (orphans.length > 0) {
+        return {
+            check,
+            status: 'drift',
+            detail: `no target declares ${orphans.join(', ')} — SwiftPM ignores them, so \`swift build\` passes without building them`,
+            hint: `Add a target named after each directory to Package.swift, or delete the directory: ${orphans.join(', ')}`,
+        };
+    }
+    return {
+        check,
+        status: 'ok',
+        detail: `all ${scanned} source directories are declared as targets`,
+    };
 }
 async function findDoccCatalogue(dir) {
     for (const target of await swiftSourceTargets(dir)) {
@@ -270,6 +334,7 @@ export async function runSwiftChecks(dir) {
         await checkPackageSwift(dir),
         ...(await Promise.all(SWIFT_FILE_CHECKS.map((spec) => checkFile(dir, spec)))),
         await checkSwiftGitignore(dir),
+        await checkSwiftTargets(dir),
         await checkSwiftTests(dir),
         await checkDocC(dir),
         await checkSwiftRelease(dir),

package/dist/languages/swift/ci.js

@@ -13,23 +13,38 @@ import { renderGitHubWorkflow, renderGitLabCI } from '../../base/ci.js';
 /** SwiftPM runs on macOS runners — Xcode isn't available anywhere else. */
 const MACOS = 'macos-latest';
 /**
- * Pull the two facts CI needs out of a Package.swift. A regex rather than a
- * SwiftPM invocation: `swift package dump-package` would need a Swift toolchain
- * on the machine running `repo-tooling`, which is usually a Node environment.
+ * Every SwiftPM target factory. `name:` is their first parameter and Swift
+ * enforces argument order, so a literal name always follows the open paren.
+ * `binaryTarget` owns no source directory but is matched anyway: the only
+ * consumer uses this set to *suppress* a report, so over-matching costs a
+ * missed finding while under-matching costs a false one.
+ */
+const TARGET_DECL = /\.(?:target|executableTarget|testTarget|macro|plugin|systemLibrary|binaryTarget)\(\s*name:\s*"([^"]+)"/g;
+/**
+ * Pull the facts doctor and CI need out of a Package.swift. A regex rather than
+ * a SwiftPM invocation: `swift package dump-package` would need a Swift
+ * toolchain on the machine running `repo-tooling`, which is usually a Node
+ * environment.
+ *
+ * ponytail: literal string arguments only. A manifest that builds its target
+ * list in a loop, behind `#if`, or from a variable parses as fewer targets than
+ * it declares — callers that act on the result must fail open. Upgrade path is
+ * `swift package dump-package` on a machine that has Swift.
  */
 export function parsePackageSwift(contents) {
     const products = [...contents.matchAll(/\.library\(\s*name:\s*"([^"]+)"/g)].map((m) => m[1]);
+    const targets = [...contents.matchAll(TARGET_DECL)].map((m) => m[1]);
     // Only the `platforms:` array declares deployment targets — matching
     // `.iOS(` across the whole manifest would also catch `.iOS` in target
     // conditionals.
     const platformsClause = contents.match(/platforms:\s*\[([^\]]*)\]/s)?.[1] ?? '';
     const platforms = [...platformsClause.matchAll(/\.(iOS|macOS|tvOS|watchOS|visionOS)\s*\(/g)].map((m) => m[1]);
-    return { products, platforms: [...new Set(platforms)] };
+    return { products, platforms: [...new Set(platforms)], targets };
 }
 export async function readSwiftPackage(dir) {
     const filepath = path.join(dir, 'Package.swift');
     if (!(await fs.pathExists(filepath)))
-        return { products: [], platforms: [] };
+        return { products: [], platforms: [], targets: [] };
     return parsePackageSwift(await fs.readFile(filepath, 'utf-8'));
 }
 /** Checkout + pin Xcode. Every Swift job needs both before it can do anything. */

package/package.json

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