@alint-js/core 0.7.0 → 0.7.2

package/dist/index.d.mts

@@ -203,6 +203,15 @@ interface RunOptions {
    * Defaults to `true`. Pass `false` for runs that target partial subsets of a project.
    */
   projectTargets?: boolean;
+  /**
+   * Only run rules whose configured id (`plugin/rule`) or own name (`rule`) matches one of these
+   * glob patterns. Everything else stays unplanned, so a filtered run neither calls its model nor
+   * reports its diagnostics.
+   *
+   * A filter that matches no enabled rule fails the run, because a silent empty run is
+   * indistinguishable from a clean one. Pass the patterns you typed on the command line.
+   */
+  ruleFilter?: readonly string[];
   runner?: RunnerOptions;
   setupConfig?: SetupConfig;
   /**

package/dist/index.mjs

@@ -14,6 +14,7 @@ import lockfile from "proper-lockfile";
 import { isNodeErrorCode } from "@alint-js/utils/node";
 import { errorMessageFrom } from "@moeru/std/error";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { setImmediate } from "node:timers/promises";
 import { streamText } from "@xsai/stream-text";
 //#region src/config/config-array.ts
 const effectiveBasePathSymbol = Symbol("effectiveBasePath");
@@ -270,7 +271,7 @@ function mergeStopGateConfig(resolved, item) {
 }
 //#endregion
 //#region package.json
-var version = "0.7.0";
+var version = "0.7.2";
 //#endregion
 //#region src/core/cache/types.ts
 const CACHE_MAGIC = "ALINT_CACHE";
@@ -1164,6 +1165,19 @@ function resolveRuleLanguages(languages) {
 	};
 }
 //#endregion
+//#region src/core/rule-filter.ts
+const minimatchOptions = { dot: true };
+/**
+* Whether one enabled rule survives a `--rule` filter.
+*
+* A pattern matches the configured rule id (`plugin/rule`) or the rule's own name
+* (`rule`), so `--rule docs/review-copy` narrows a run to a single rule while
+* `--rule 'docs/*'` keeps a plugin's rules. Patterns are matched with glob syntax.
+*/
+function matchesRuleFilter(rule, patterns) {
+	return patterns.some((pattern) => minimatch(rule.id, pattern, minimatchOptions) || minimatch(rule.localId, pattern, minimatchOptions));
+}
+//#endregion
 //#region src/core/preparation.ts
 /**
 * The `ctx.src.extract` a run hands to rules, for parsing files it was never asked to lint, which
@@ -1196,10 +1210,17 @@ function createSourceExtractor(cwd, config, getSrc) {
 function prepareRun(options = {}) {
 	const cwd$2 = options.cwd ?? cwd();
 	const config = options.config ?? [];
+	const ruleFilter = options.ruleFilter ?? [];
 	const files = [];
 	const directories = [];
+	const knownRuleIds = /* @__PURE__ */ new Set();
 	const missingLanguages = /* @__PURE__ */ new Map();
 	const unregisteredLanguages = /* @__PURE__ */ new Map();
+	const prepareRulesFor = (effectiveConfig) => {
+		const enabledRules = buildRuleRegistry(effectiveConfig).enabledRules;
+		for (const enabledRule of enabledRules) knownRuleIds.add(enabledRule.id);
+		return prepareRules(enabledRules, ruleFilter);
+	};
 	for (const filePath of options.files ?? []) {
 		const path = resolve(cwd$2, filePath);
 		const resolvedConfig = resolveConfigForFile(path, config, { cwd: cwd$2 });
@@ -1207,7 +1228,7 @@ function prepareRun(options = {}) {
 		const effectiveConfig = resolvedConfig.config;
 		const languageRegistry = createLanguageRegistry(effectiveConfig);
 		const language = resolveLanguageForPath(path, languageRegistry, { language: effectiveConfig.language });
-		const rules = prepareRules(effectiveConfig);
+		const rules = prepareRulesFor(effectiveConfig);
 		recordMissingLanguages(missingLanguages, rules, languageRegistry, path);
 		if (effectiveConfig.language === void 0 && language.name === "plaintext" && rules.some(({ enabledRule }) => !isTargetLanguageAccepted(resolveRuleLanguages(enabledRule.rule.languages), "file", "plaintext"))) recordUnregistered(unregisteredLanguages, path, unregisteredLanguageSeverity(effectiveConfig.linterOptions));
 		files.push({
@@ -1236,7 +1257,7 @@ function prepareRun(options = {}) {
 			agent: effectiveConfig.agent,
 			configHash: stableHash({ settings: effectiveConfig.settings }),
 			directoryIndex: directories.length,
-			rules: prepareRules(effectiveConfig),
+			rules: prepareRulesFor(effectiveConfig),
 			settings: effectiveConfig.settings,
 			target: {
 				kind: "directory",
@@ -1244,11 +1265,13 @@ function prepareRun(options = {}) {
 			}
 		});
 	}
+	const project = options.projectTargets === false ? void 0 : prepareProject(cwd$2, config, prepareRulesFor);
+	if (ruleFilter.length > 0 && !hasPreparedRule(files, directories, project)) throw new Error(formatUnmatchedRuleFilter(ruleFilter, knownRuleIds));
 	return {
 		directories,
 		files,
 		missingLanguages,
-		project: options.projectTargets === false ? void 0 : prepareProject(cwd$2, config),
+		project,
 		unregisteredLanguages
 	};
 }
@@ -1257,7 +1280,15 @@ function createLanguageRegistry(config) {
 	for (const plugin of Object.values(config.plugins)) for (const language of Object.values(plugin.languages ?? {})) registerLanguage(registry, language);
 	return registry;
 }
-function prepareProject(root, config) {
+function formatUnmatchedRuleFilter(ruleFilter, knownRuleIds) {
+	const patterns = ruleFilter.map((pattern) => `"${pattern}"`).join(", ");
+	const knownIds = [...knownRuleIds].sort();
+	return `No enabled rule matched --rule ${patterns}. ${knownIds.length === 0 ? "This run enabled no rule at all. Run `alint config inspect <file>` to see which rules apply to a file." : `Enabled rules: ${knownIds.slice(0, 20).join(", ")}${knownIds.length > 20 ? ", ..." : ""}.`}`;
+}
+function hasPreparedRule(files, directories, project) {
+	return files.some((input) => input.rules.length > 0) || directories.some((input) => input.rules.length > 0) || (project?.rules.length ?? 0) > 0;
+}
+function prepareProject(root, config, prepareRulesFor) {
 	const resolvedConfig = resolveConfigForProject(root, config, { cwd: root });
 	if (resolvedConfig.ignored) return void 0;
 	const effectiveConfig = resolvedConfig.config;
@@ -1265,15 +1296,19 @@ function prepareProject(root, config) {
 		agent: effectiveConfig.agent,
 		configHash: stableHash({ settings: effectiveConfig.settings }),
 		root,
-		rules: prepareRules(effectiveConfig),
+		rules: prepareRulesFor(effectiveConfig),
 		settings: effectiveConfig.settings
 	};
 }
-function prepareRules(config) {
-	return buildRuleRegistry(config).enabledRules.map((enabledRule, ruleIndex) => ({
+/**
+* Keeps the registry position of every surviving rule: `ruleIndex` is an enabled-registry
+* position that jobs and progress refs share, so filtering must not renumber the rules that stay.
+*/
+function prepareRules(enabledRules, ruleFilter) {
+	return enabledRules.map((enabledRule, ruleIndex) => ({
 		enabledRule,
 		ruleIndex
-	}));
+	})).filter((rule) => ruleFilter.length === 0 || matchesRuleFilter(rule.enabledRule, ruleFilter));
 }
 function recordMissingLanguages(into, rules, registry, path) {
 	for (const { enabledRule } of rules) {
@@ -2363,88 +2398,14 @@ function projectExecution(runtime) {
 //#endregion
 //#region src/core/source/planner.ts
 /**
-* Converts one rich extractor result into detached descriptors and admits its compact jobs.
-*
-* The returned outcome promise captures only cache ownership and hashes. This function does not
-* await rule execution, so its `SourceFile`, parser output, and rich targets become unreachable
-* when planning returns.
-*/
-async function planSource(input, options) {
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let file;
-	try {
-		file = await options.src.readFile(input.path);
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
-	let targets;
-	try {
-		targets = await input.language.extract(file, {
-			cwd: options.cwd,
-			languageOptions: input.languageOptions,
-			src: options.src
-		});
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	const { contentHash } = file;
-	let cacheOwner;
-	let jobs;
-	let project;
-	try {
-		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
-		cacheOwner = options.cacheStore.beginOwner({
-			kind: "file",
-			path: file.path
-		}, { contentHash });
-		const baseFile = {
-			contentHash,
-			language: file.language,
-			path: file.path
-		};
-		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
-	} catch (error) {
-		reportFilePlanningComplete(input, 0, options);
-		return {
-			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
-			outcomes: Promise.resolve([])
-		};
-	}
-	if (options.signal?.aborted) {
-		cacheOwner.commit({ mode: "merge" });
-		return {
-			outcomes: Promise.resolve([]),
-			project
-		};
-	}
-	const batch = options.scheduler.schedule(jobs);
-	reportFilePlanningComplete(input, batch.jobsAdded, options);
-	return {
-		outcomes: batch.outcomes.then(async (settled) => {
-			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
-			await options.cacheStore.flush();
-			return settled;
-		}),
-		project
-	};
-}
-/**
-* Starts every input plan independently and preserves input-ordered results.
+* Starts every input read independently, then batches CPU-heavy extraction and job admission.
 */
 async function planSources(inputs, options) {
-	return Promise.all(inputs.map((input) => planSource(input, {
+	const waitForPlanning = createPlanningAdmission();
+	return Promise.all(inputs.map((input) => planSourceWithAdmission(input, {
 		...options,
 		ruleRuntimes: options.createRuleRuntimes(input)
-	})));
+	}, waitForPlanning)));
 }
 function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner) {
 	const resolveIdentity = createTargetIdentityResolver(targets.map((target) => ({
@@ -2499,6 +2460,28 @@ function createExecutionTargets(input, targets, file, runtimes, cwd, cacheOwner)
 		};
 	});
 }
+function createPlanningAdmission() {
+	const batchSize = 32;
+	let admitted = 0;
+	let pendingYield;
+	return async () => {
+		let currentPendingYield = pendingYield;
+		while (currentPendingYield) {
+			await currentPendingYield;
+			currentPendingYield = pendingYield;
+		}
+		admitted += 1;
+		if (admitted < batchSize) return;
+		admitted = 0;
+		const currentYield = setImmediate();
+		pendingYield = currentYield;
+		try {
+			await currentYield;
+		} finally {
+			if (pendingYield === currentYield) pendingYield = void 0;
+		}
+	};
+}
 function createProjectSnapshot(input, language, path, contentHash, targets) {
 	return {
 		configHash: input.configHash,
@@ -2570,6 +2553,76 @@ function fileFailure(input, kind, message) {
 		message
 	};
 }
+async function planSourceWithAdmission(input, options, waitForPlanning) {
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let file;
+	try {
+		file = await options.src.readFile(input.path);
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "read", failureMessage(error, "Failed to read source file.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	await waitForPlanning?.();
+	if (options.signal?.aborted) return { outcomes: Promise.resolve([]) };
+	let targets;
+	try {
+		targets = await input.language.extract(file, {
+			cwd: options.cwd,
+			languageOptions: input.languageOptions,
+			src: options.src
+		});
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to extract source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	const { contentHash } = file;
+	let cacheOwner;
+	let jobs;
+	let project;
+	try {
+		project = options.projectSnapshots === false ? void 0 : createProjectSnapshot(input, file.language, file.path, contentHash, targets);
+		cacheOwner = options.cacheStore.beginOwner({
+			kind: "file",
+			path: file.path
+		}, { contentHash });
+		const baseFile = {
+			contentHash,
+			language: file.language,
+			path: file.path
+		};
+		jobs = createSourceJobs(input, createExecutionTargets(input, targets, baseFile, options.ruleRuntimes, options.cwd, cacheOwner));
+	} catch (error) {
+		reportFilePlanningComplete(input, 0, options);
+		return {
+			failure: fileFailure(input, "extract", failureMessage(error, "Failed to plan source targets.")),
+			outcomes: Promise.resolve([])
+		};
+	}
+	if (options.signal?.aborted) {
+		cacheOwner.commit({ mode: "merge" });
+		return {
+			outcomes: Promise.resolve([]),
+			project
+		};
+	}
+	const batch = options.scheduler.schedule(jobs);
+	reportFilePlanningComplete(input, batch.jobsAdded, options);
+	return {
+		outcomes: batch.outcomes.then(async (settled) => {
+			cacheOwner.commit(options.signal?.aborted ? { mode: "merge" } : void 0);
+			await options.cacheStore.flush();
+			return settled;
+		}),
+		project
+	};
+}
 function reportFilePlanningComplete(input, jobsAdded, options) {
 	try {
 		const progress = options.scheduler.completeFilePlanning();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Public rule and plugin SDK and run engine for alint",
   "license": "MIT",
   "repository": {
@@ -56,7 +56,7 @@
     "pathe": "^2.0.3",
     "proper-lockfile": "4.1.2",
     "valibot": "^1.4.2",
-    "@alint-js/utils": "0.7.0"
+    "@alint-js/utils": "0.7.2"
   },
   "devDependencies": {
     "@types/proper-lockfile": "4.1.4",