@alint-js/core 0.7.1 → 0.7.3

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

@@ -271,7 +271,7 @@ function mergeStopGateConfig(resolved, item) {
 }
 //#endregion
 //#region package.json
-var version = "0.7.1";
+var version = "0.7.3";
 //#endregion
 //#region src/core/cache/types.ts
 const CACHE_MAGIC = "ALINT_CACHE";
@@ -1165,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
@@ -1197,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 });
@@ -1208,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({
@@ -1237,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",
@@ -1245,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
 	};
 }
@@ -1258,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;
@@ -1266,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) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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.1"
+    "@alint-js/utils": "0.7.3"
   },
   "devDependencies": {
     "@types/proper-lockfile": "4.1.4",