Add --rules CLI option to run specific rules ignoring .editorconfig

Accepts comma-separated rule IDs (e.g., --rules CSLINT266,CSLINT268) or
'all' to enable every rule. Validates rule IDs and exits with error on
unknown IDs.

🤖 Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: lucaspimentel

src/CsLint.Cli/Program.cs

@@ -50,6 +50,11 @@
     Description = "Show a summary of diagnostics grouped by rule ID",
 };
 
+var rulesOption = new Option<string>("--rules")
+{
+    Description = "Comma-separated rule IDs to run (e.g., CSLINT266,CSLINT268), or 'all' to enable every rule. Ignores .editorconfig when set.",
+};
+
 var versionOption = new Option<bool>("--version")
 {
     Description = "Show version information and exit",
@@ -65,6 +70,7 @@
     showConfigOption,
     semanticOption,
     summaryOption,
+    rulesOption,
     versionOption,
 };
 
@@ -131,9 +137,50 @@
 #endif
 
     RuleRegistry registry = RuleRegistry.CreateDefault();
+    string? rulesValue = parseResult.GetValue(rulesOption);
+
+    HashSet<string>? ruleFilter = null;
+    bool skipEnabledCheck = false;
+
+    if (rulesValue is not null)
+    {
+        if (string.Equals(rulesValue, "all", StringComparison.OrdinalIgnoreCase))
+        {
+            skipEnabledCheck = true;
+        }
+        else
+        {
+            var knownIds = new HashSet<string>(registry.Rules.Select(r => r.RuleId), StringComparer.OrdinalIgnoreCase);
+            string[] requested = rulesValue.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+            if (requested.Length == 0)
+            {
+                Console.Error.WriteLine("--rules requires at least one rule ID or 'all'.");
+                return 2;
+            }
+
+            ruleFilter = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (string id in requested)
+            {
+                if (!knownIds.Contains(id))
+                {
+                    Console.Error.WriteLine($"Unknown rule ID: {id}");
+                    return 2;
+                }
+
+                ruleFilter.Add(id);
+            }
+
+            skipEnabledCheck = true;
+        }
+    }
+
     var configProvider = new EditorConfigProvider();
     var fileLinter = new FileLinter(registry, configProvider)
     {
+        RuleFilter = ruleFilter,
+        SkipEnabledCheck = skipEnabledCheck,
 #if SEMANTIC
         EnableSemantic = semantic,
 #endif

src/CsLint.Core/Engine/FileLinter.cs

@@ -13,6 +13,10 @@ namespace Cslint.Core.Engine;
 
 public sealed class FileLinter(RuleRegistry registry, IConfigProvider configProvider)
 {
+    public HashSet<string>? RuleFilter { get; set; }
+
+    public bool SkipEnabledCheck { get; set; }
+
 #if SEMANTIC
     public bool EnableSemantic { get; set; }
 
@@ -135,7 +139,12 @@ public IReadOnlyList<LintDiagnostic> LintSource(
 
         foreach (IRuleDefinition rule in registry.Rules)
         {
-            if (!rule.IsEnabled(configuration))
+            if (RuleFilter is not null && !RuleFilter.Contains(rule.RuleId))
+            {
+                continue;
+            }
+
+            if (!SkipEnabledCheck && !rule.IsEnabled(configuration))
             {
                 continue;
             }

test/CsLint.Core.Tests/Engine/FileLinterTests.cs

@@ -5,7 +5,7 @@
 
 namespace Cslint.Core.Tests.Engine;
 
-public class FileLinterTests
+public sealed class FileLinterTests
 {
     [Fact]
     public void LintSource_WithEnabledRule_ReturnsLintDiagnostics()
@@ -171,4 +171,68 @@ public void LintSource_TrueWithSeveritySuffix_RuleIsEnabled()
         Assert.NotEmpty(diagnostics);
         Assert.Contains(diagnostics, d => d.RuleId == "CSLINT001");
     }
+
+    [Fact]
+    public void LintSource_RuleFilter_OnlyRunsSpecifiedRules()
+    {
+        // Enable two rules via config, but filter to only one
+        var config = new LintConfiguration(
+            new Dictionary<string, string>
+            {
+                ["trim_trailing_whitespace"] = "true",
+                ["insert_final_newline"] = "true",
+            });
+
+        RuleRegistry registry = RuleRegistry.CreateDefault();
+        var mockProvider = new Mock<IConfigProvider>();
+        var linter = new FileLinter(registry, mockProvider.Object)
+        {
+            RuleFilter = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CSLINT001" },
+            SkipEnabledCheck = true,
+        };
+
+        // Source has trailing whitespace (CSLINT001) and no final newline (CSLINT002)
+        IReadOnlyList<LintDiagnostic> diagnostics = linter.LintSource("test.cs", "class Foo { }   ", config);
+
+        Assert.Contains(diagnostics, d => d.RuleId == "CSLINT001");
+        Assert.DoesNotContain(diagnostics, d => d.RuleId == "CSLINT002");
+    }
+
+    [Fact]
+    public void LintSource_SkipEnabledCheck_RunsRuleEvenWhenConfigDisabled()
+    {
+        // Config does not enable the rule
+        var config = new LintConfiguration(new Dictionary<string, string>());
+
+        RuleRegistry registry = RuleRegistry.CreateDefault();
+        var mockProvider = new Mock<IConfigProvider>();
+        var linter = new FileLinter(registry, mockProvider.Object)
+        {
+            RuleFilter = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "CSLINT001" },
+            SkipEnabledCheck = true,
+        };
+
+        IReadOnlyList<LintDiagnostic> diagnostics = linter.LintSource("test.cs", "class Foo { }   \n", config);
+
+        Assert.Contains(diagnostics, d => d.RuleId == "CSLINT001");
+    }
+
+    [Fact]
+    public void LintSource_SkipEnabledCheckWithoutFilter_RunsAllRules()
+    {
+        // Empty config — normally no Tier1 rules would be enabled
+        var config = new LintConfiguration(new Dictionary<string, string>());
+
+        RuleRegistry registry = RuleRegistry.CreateDefault();
+        var mockProvider = new Mock<IConfigProvider>();
+        var linter = new FileLinter(registry, mockProvider.Object)
+        {
+            SkipEnabledCheck = true,
+        };
+
+        IReadOnlyList<LintDiagnostic> diagnostics = linter.LintSource("test.cs", "class Foo { }   \n", config);
+
+        // With all rules force-enabled, we should get trailing whitespace at minimum
+        Assert.Contains(diagnostics, d => d.RuleId == "CSLINT001");
+    }
 }