@theholocron/astromech 5.0.0-alpha.77 → 5.0.0-alpha.79

package/README.md

@@ -33,7 +33,7 @@ const report = astromech.run("verification.unitTests", { passthrough: ["--watch"
 `holocron run verification.unitTests` runs your tests — you don't tell it
 turbo vs pnpm vs npm, or which runner:
 
-```
+```text
 1. turbo.json defines the task            → turbo run <task>
 2. package.json has a <task> script       → <detected pm> run <task>
    (a "holocron run …" thin caller is skipped — no recursion)
@@ -83,10 +83,12 @@ publish/deploy-shaped task can carry, toggled via that task's `with:`.
 
 **`linterGroup` tasks** (`sourceQuality.staticAnalysis`,
 `sourceQuality.formatting`) bundle more than one tool under a single
-required check. Each tool is still gated by its own detection rule (e.g.
-`eslint` only runs if `eslint.config.*` is present) — the
+required check. Each tool is still gated by its own detection rule — e.g.
+`eslint` runs when either a local `eslint.config.*` is present, or the
+package has no local file but `@theholocron/eslint-config` resolves
+(the same shared-config splice the `tool`/`detect` runner path uses) — the
 `tool name → detection rule → local binary` mapping lives in one place,
-`src/linters.ts`. A repo's choice of which of these run is just which
+`src/linters.ts`. A repo's choice of which of these run is based on which
 tasks it includes in `tasks: [...]`, same as any other task.
 
 **No super-linter.** Each task above runs its own tool directly, through

package/dist/index.d.mts

@@ -332,10 +332,14 @@ interface Astromech {
    * (not just an orchestrator) silently vanishes from `turbo run <task>`.
    * Pass `pnpm-workspace.yaml`'s current content (or `""` if none exists —
    * a no-op either way, since no `packages:` key means single-package mode
-   * already) and root `package.json`'s own `scripts` keys. `changed: false`
-   * means don't write anything — the file is already correct.
+   * already) and root `package.json`'s own `scripts` object — values and
+   * all, not just keys, so a task-name-matching script that's already the
+   * generated `holocron run <task> --` wrapper (predating this call, not
+   * written by it) is correctly excluded rather than treated as proof root
+   * is directly buildable (#846). `changed: false` means don't write
+   * anything — the file is already correct.
    */
-  ensureRootWorkspaceMember(workspaceYaml: string, rootScripts: readonly string[]): EnsureRootWorkspaceMemberResult;
+  ensureRootWorkspaceMember(workspaceYaml: string, rootScripts: Readonly<Record<string, string>>): EnsureRootWorkspaceMemberResult;
   /**
    * `turboConfig()` writes a `turbo.json` but never touches `package.json`
    * — a repo with no local `turbo` devDependency falls back to whatever
@@ -448,11 +452,20 @@ declare const LINTER_NAMES: ReadonlySet<string>;
  * Resolve the linter set for a repo. An `explicit` list (from `config.tasks`)
  * picks the candidate set; otherwise the candidates are every `always` linter
  * plus every `detect`-gated linter whose filenames are present at the repo
- * root. Either way, a `detect`-gated linter (eslint, markdownlint) only makes
- * the final set when its config file is actually present — a repo can't run
- * eslint without an `eslint.config.*`, and super-linter FATALs if you ask it
- * to (theholocron/holocron#654). `always` linters are unconditional. Result
- * is ordered by {@link LINTERS} declaration order.
+ * root, OR whose mapped `@theholocron/*-config` package resolves per
+ * {@link sharedConfigAvailable} — a repo can't run eslint with genuinely no
+ * config anywhere (super-linter FATALs if you ask it to,
+ * theholocron/holocron#654), but a *shared* one it has installed counts
+ * (holocron#795: proving `clients`' eslint.config.ts files reduce to zero
+ * remaining content is only half the story — the file itself was still load-
+ * bearing here as the sole "eslint is even configured" signal until this
+ * fallback existed). `always` linters are unconditional. Result is ordered
+ * by {@link LINTERS} declaration order.
+ *
+ * `sharedConfigAvailable` is caller-computed (`run.ts`'s `runLinterGroup`
+ * already resolves each linter's `resolveToolConfig()` per member to build
+ * its actual command — reusing that instead of duplicating the package-
+ * resolution logic here keeps this function itself pure and file-I/O-free).
  *
  * @throws when an `explicit` name is not in the registry — a typo is a
  * config bug, not a linter to silently skip.
@@ -460,6 +473,7 @@ declare const LINTER_NAMES: ReadonlySet<string>;
 declare function resolveLinters(opts: {
   explicit?: string[];
   rootFiles: string[];
+  sharedConfigAvailable?: ReadonlySet<string>;
 }): Array<{
   name: string;
   def: LinterDef;

package/dist/index.mjs

@@ -299,11 +299,20 @@ const LINTER_NAMES = new Set(Object.keys(LINTERS));
 * Resolve the linter set for a repo. An `explicit` list (from `config.tasks`)
 * picks the candidate set; otherwise the candidates are every `always` linter
 * plus every `detect`-gated linter whose filenames are present at the repo
-* root. Either way, a `detect`-gated linter (eslint, markdownlint) only makes
-* the final set when its config file is actually present — a repo can't run
-* eslint without an `eslint.config.*`, and super-linter FATALs if you ask it
-* to (theholocron/holocron#654). `always` linters are unconditional. Result
-* is ordered by {@link LINTERS} declaration order.
+* root, OR whose mapped `@theholocron/*-config` package resolves per
+* {@link sharedConfigAvailable} — a repo can't run eslint with genuinely no
+* config anywhere (super-linter FATALs if you ask it to,
+* theholocron/holocron#654), but a *shared* one it has installed counts
+* (holocron#795: proving `clients`' eslint.config.ts files reduce to zero
+* remaining content is only half the story — the file itself was still load-
+* bearing here as the sole "eslint is even configured" signal until this
+* fallback existed). `always` linters are unconditional. Result is ordered
+* by {@link LINTERS} declaration order.
+*
+* `sharedConfigAvailable` is caller-computed (`run.ts`'s `runLinterGroup`
+* already resolves each linter's `resolveToolConfig()` per member to build
+* its actual command — reusing that instead of duplicating the package-
+* resolution logic here keeps this function itself pure and file-I/O-free).
 *
 * @throws when an `explicit` name is not in the registry — a typo is a
 * config bug, not a linter to silently skip.
@@ -311,17 +320,18 @@ const LINTER_NAMES = new Set(Object.keys(LINTERS));
 function resolveLinters(opts) {
 	const order = Object.keys(LINTERS);
 	const present = new Set(opts.rootFiles);
-	const configPresent = (def) => def.always === true || (def.detect ?? []).some((f) => present.has(f));
+	const shared = opts.sharedConfigAvailable ?? /* @__PURE__ */ new Set();
+	const configPresent = (name, def) => def.always === true || (def.detect ?? []).some((f) => present.has(f)) || shared.has(name);
 	if (opts.explicit && opts.explicit.length > 0) {
 		const unknown = opts.explicit.filter((n) => !LINTER_NAMES.has(n));
 		if (unknown.length > 0) throw new Error(`unknown linter${unknown.length > 1 ? "s" : ""} ${unknown.map((n) => `"${n}"`).join(", ")} — known: ${order.join(", ")}`);
 		const wanted = new Set(opts.explicit);
-		return order.filter((n) => wanted.has(n) && configPresent(LINTERS[n])).map((name) => ({
+		return order.filter((n) => wanted.has(n) && configPresent(n, LINTERS[n])).map((name) => ({
 			name,
 			def: LINTERS[name]
 		}));
 	}
-	return order.filter((name) => configPresent(LINTERS[name])).map((name) => ({
+	return order.filter((name) => configPresent(name, LINTERS[name])).map((name) => ({
 		name,
 		def: LINTERS[name]
 	}));
@@ -731,9 +741,14 @@ function runLinterGroup(input, names, passthrough) {
 	} catch {
 		rootFiles = [];
 	}
+	const sharedConfigAvailable = new Set(names.filter((name) => resolveToolConfig(name, cwd, {
+		readFile,
+		fileExists
+	}).length > 0));
 	const resolved = resolveLinters({
 		explicit: names,
-		rootFiles
+		rootFiles,
+		sharedConfigAvailable
 	});
 	const reports = [];
 	let anyHasLocalBin = false;
@@ -1544,6 +1559,17 @@ function turboConfig(config) {
 * (`Packages in scope: docs, root-lib`) without disturbing the sibling
 * package's own caching.
 *
+* A matching script key alone isn't enough — its *value* has to be a real
+* command, not the generated `holocron run <task> --` wrapper (#846, the
+* counterpart `mergePackageJsonScripts()` already had to learn for #747/
+* #748). A repo whose root predates this tooling can already have that exact
+* wrapper sitting in a task-name-matching script with nothing ever having
+* generated it this session; adding `.` there fires #747's recursion
+* immediately (`turbo run <task>` → root's own `<task>` script → the wrapper
+* → `holocron run <task>` sees `turbo.json` still defines it → `turbo run
+* <task>` again, forever). Only a matching script whose value is *not* that
+* wrapper counts as "root is genuinely a directly-buildable package".
+*
 * A targeted line-based edit, not a full YAML parse/reserialize — same
 * pattern `codecov.ts`'s `mergeCodecovComponents()` already uses for editing
 * an existing generated file. `pnpm-workspace.yaml` routinely carries a
@@ -1555,7 +1581,10 @@ function turboConfig(config) {
 * every repo checked actually uses.
 */
 function ensureRootWorkspaceMember(workspaceYaml, rootScripts, taskNames) {
-	if (!taskNames.some((t) => rootScripts.includes(t))) return {
+	if (!taskNames.some((t) => {
+		const script = rootScripts[t];
+		return script !== void 0 && !isGeneratedRunWrapper(script, t);
+	})) return {
 		content: workspaceYaml,
 		changed: false
 	};
@@ -1589,6 +1618,21 @@ function ensureRootWorkspaceMember(workspaceYaml, rootScripts, taskNames) {
 	};
 }
 /**
+* Matches the exact shape `packageScripts()` generates for `taskName` —
+* `<bin> run <taskName> --`, `<bin>` normally `holocron` but substitutable
+* (`holocronScript`, itself allowed to be multi-word, e.g. `"node
+* packages/cli/dist/cli.mjs"` — see its own test). Checking the *suffix*
+* rather than the whole string means an old wrapper survives a
+* `holocronScript` rename intact — it's still recognized as a wrapper (safe
+* to update to the new one), not mistaken for a real command. Mirrors
+* `sync.ts`'s private `isGeneratedRunWrapper()` — same predicate, needed on
+* both sides of #692/#747: whether to *write* the wrapper, and here, whether
+* an *existing* one should count as "root is directly buildable".
+*/
+function isGeneratedRunWrapper(command, taskName) {
+	return command.endsWith(` run ${taskName} --`);
+}
+/**
 * Fallback pin when a repo's own `pnpm-workspace.yaml` has no `turbo`
 * catalog entry yet — matches this repo's own catalog version (the
 * canonical source-of-truth repo for the whole org's tooling).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theholocron/astromech",
-  "version": "5.0.0-alpha.77",
+  "version": "5.0.0-alpha.79",
   "description": "The Holocron task runner — one task manifest drives `holocron run`, `holocron ci`, the CI workflows, package.json scripts, linters, and required checks.",
   "keywords": [
     "ci",
@@ -37,7 +37,7 @@
     "dist"
   ],
   "dependencies": {
-    "@theholocron/datapad": "5.0.0-alpha.77"
+    "@theholocron/datapad": "5.0.0-alpha.79"
   },
   "devDependencies": {
     "@theholocron/eslint-config": "^8.4.5",
@@ -53,7 +53,7 @@
     "tsdown": "^0.22.14",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "@theholocron/rollup-plugin-transform-template": "5.0.0-alpha.77"
+    "@theholocron/rollup-plugin-transform-template": "5.0.0-alpha.79"
   },
   "engines": {
     "node": ">=22"