Add --changed-only to developer-cli lint command (opt-in) and rename detect-changes to detect-scope

Author: tjementum

.claude/skills/lint/SKILL.md

@@ -6,7 +6,7 @@ description: Lint code via the developer CLI - backend (.NET via JetBrains inspe
 # Lint
 
 ```bash
-dotnet run --project developer-cli -- lint [--backend] [--frontend] [--cli] [--self-contained-system <name>] [--no-build] --quiet
+dotnet run --project developer-cli -- lint [--backend] [--frontend] [--cli] [--self-contained-system <name>] [--no-build] [--changed-only] --quiet
 ```
 
 Use `developer-cli` exactly as written - do not expand to an absolute worktree path.
@@ -16,18 +16,28 @@ Use `developer-cli` exactly as written - do not expand to an absolute worktree p
 - `--cli` - the developer CLI itself
 - `--self-contained-system <name>` - narrows backend linting to one SCS (e.g. `account`, `main`)
 - `--no-build` - skip the rebuild step (faster after a recent build)
+- `--changed-only` - lint only `.cs` files changed against `origin/main` (much faster; see guidance below)
 
-No arguments lints everything. Every finding fails CI regardless of severity - fix all of them.
+No arguments lints the whole solution. Every finding fails CI regardless of severity - fix all of them.
 
 After `build` succeeds, run `format`, `lint`, `test` in parallel with `--no-build`. Backend lint is slow - run last. Frontend lint often needs code rewrites - run after each bigger change.
 
+## When to use `--changed-only`
+
+Inspectcode has cross-file rules ("unused public method", "member can be private", flow analysis across method calls). `--changed-only` only inspects the listed files - it doesn't catch issues in untouched files that became invalid because of edits elsewhere.
+
+- **Routine work:** use `--changed-only`. Most lint findings are local (style, naming, hints) and the saving is large (~4m → ~30s).
+- **Larger changes that affect other files** (refactoring a public API, deleting a method's only caller, changing a widely-used type): omit `--changed-only` and lint the full solution.
+
+CI always lints the full solution, so anything missed by a local `--changed-only` run gets caught before merge.
+
 ## Examples
 
 ```bash
-dotnet run --project developer-cli -- lint --quiet                                          # everything
-dotnet run --project developer-cli -- lint --backend --quiet                                # all backend
-dotnet run --project developer-cli -- lint --frontend --quiet                               # frontend
-dotnet run --project developer-cli -- lint --backend --self-contained-system main --quiet   # one SCS
+dotnet run --project developer-cli -- lint --quiet                                                # everything (full solution)
+dotnet run --project developer-cli -- lint --backend --changed-only --quiet                       # backend, changed files only (recommended for routine work)
+dotnet run --project developer-cli -- lint --frontend --quiet                                     # frontend
+dotnet run --project developer-cli -- lint --backend --self-contained-system main --quiet         # one SCS, full
 ```
 
 ## Always pass --quiet

.github/workflows/code-style.yml

@@ -23,13 +23,14 @@ permissions:
   pull-requests: write
 
 jobs:
-  detect-changes:
-    name: Detect Changes
+  detect-scope:
+    name: Detect Scope
     runs-on: ubuntu-24.04
     outputs:
       backend_scope: ${{ steps.scope.outputs.backend_scope }}
       backend_label: ${{ steps.scope.outputs.backend_label }}
       format_all_files_flag: ${{ steps.scope.outputs.format_all_files_flag }}
+      format_label: ${{ steps.scope.outputs.format_label }}
     steps:
       - name: Checkout Code
         uses: actions/checkout@v6
@@ -82,8 +83,9 @@ jobs:
           fi
 
           # Force --all-files when the JetBrains tool manifest moves. Tool upgrades change the
-          # cleanupcode rule set, so latent formatting drift in untouched files needs reformatting
-          # in the same PR. Otherwise the next PR that happens to touch one of those files fails CI.
+          # inspectcode + cleanupcode rule sets, so latent issues in untouched files need to be
+          # caught in the same PR. Otherwise the next PR that happens to touch one of those files
+          # fails CI on issues it didn't introduce.
           if echo "$changed" | grep -q '^application/dotnet-tools.json$'; then
             echo "format_all_files_flag=--all-files" >> "$GITHUB_OUTPUT"
             echo "format_label=all files (JetBrains tools upgraded)" >> "$GITHUB_OUTPUT"
@@ -95,11 +97,11 @@ jobs:
       - name: Print Scope
         run: |
           echo "Backend scope - ${{ steps.scope.outputs.backend_label }}"
-          echo "Format scope  - ${{ steps.scope.outputs.format_label }}"
+          echo "Format mode   - ${{ steps.scope.outputs.format_label }}"
 
   code-linting:
     name: Code Linting
-    needs: detect-changes
+    needs: detect-scope
     runs-on: ubuntu-24.04
 
     steps:
@@ -130,12 +132,12 @@ jobs:
 
       - name: Build Backend Solution
         working-directory: developer-cli
-        run: dotnet run -- build --backend ${{ needs.detect-changes.outputs.backend_scope }} --quiet
+        run: dotnet run -- build --backend ${{ needs.detect-scope.outputs.backend_scope }} --quiet
 
       - name: Run Backend Linting
         working-directory: developer-cli
         run: |
-          dotnet run lint --backend ${{ needs.detect-changes.outputs.backend_scope }} --no-build | tee lint-output.log
+          dotnet run lint --backend ${{ needs.detect-scope.outputs.backend_scope }} --no-build | tee lint-output.log
 
           if ! grep -q "No backend issues found!" lint-output.log; then
             echo "Code linting issues found."
@@ -162,7 +164,7 @@ jobs:
 
   code-formatting:
     name: Code Formatting
-    needs: detect-changes
+    needs: detect-scope
     runs-on: ubuntu-24.04
 
     steps:
@@ -193,21 +195,21 @@ jobs:
 
       - name: Build Backend Solution
         working-directory: developer-cli
-        run: dotnet run -- build --backend ${{ needs.detect-changes.outputs.backend_scope }} --quiet
+        run: dotnet run -- build --backend ${{ needs.detect-scope.outputs.backend_scope }} --quiet
 
       - name: Check for Code Formatting Issues
         working-directory: developer-cli
         run: |
-          dotnet run format --backend ${{ needs.detect-changes.outputs.backend_scope }} ${{ needs.detect-changes.outputs.format_all_files_flag }} --no-build
+          dotnet run format --backend ${{ needs.detect-scope.outputs.backend_scope }} ${{ needs.detect-scope.outputs.format_all_files_flag }} --no-build
 
           git diff --exit-code || {
-            echo "Formatting issues detected. Please run 'dotnet run --project developer-cli -- format --backend ${{ needs.detect-changes.outputs.backend_scope }} ${{ needs.detect-changes.outputs.format_all_files_flag }}' locally and commit the formatted code."
+            echo "Formatting issues detected. Please run 'dotnet run --project developer-cli -- format --backend ${{ needs.detect-scope.outputs.backend_scope }} ${{ needs.detect-scope.outputs.format_all_files_flag }}' locally and commit the formatted code."
             exit 1
           }
 
   sonarcloud:
     name: SonarCloud Analysis
-    needs: detect-changes
+    needs: detect-scope
     runs-on: ubuntu-24.04
 
     steps:

developer-cli/Commands/FormatCommand.cs

@@ -134,7 +134,7 @@ private static void RunBackendFormat(string? selfContainedSystem, bool noBuild,
         var includeArgument = string.Empty;
         if (!allFiles)
         {
-            var changedCsFiles = GetChangedCsFiles(solutionFile.Directory!.FullName);
+            var changedCsFiles = GitHelper.GetChangedCsFilesInDirectory(solutionFile.Directory!.FullName);
             if (changedCsFiles.Length == 0)
             {
                 if (!quiet) AnsiConsole.MarkupLine("[green]No changed C# files found, skipping backend format.[/]");
@@ -173,7 +173,7 @@ private static void RunDeveloperCliFormat(bool noBuild, bool allFiles, bool quie
         var includeArgument = string.Empty;
         if (!allFiles)
         {
-            var changedCsFiles = GetChangedCsFiles(solutionFile.Directory!.FullName);
+            var changedCsFiles = GitHelper.GetChangedCsFilesInDirectory(solutionFile.Directory!.FullName);
             if (changedCsFiles.Length == 0)
             {
                 if (!quiet) AnsiConsole.MarkupLine("[green]No changed C# files found, skipping developer-cli format.[/]");
@@ -197,20 +197,4 @@ private static void RunDeveloperCliFormat(bool noBuild, bool allFiles, bool quie
         );
     }
 
-    // Returns relative paths (relative to solutionDirectory) of .cs files changed compared to origin/main.
-    // Fetches origin/main first so this works on shallow CI clones; the fetch is best-effort and silent on failure.
-    private static string[] GetChangedCsFiles(string solutionDirectory)
-    {
-        ProcessHelper.StartProcess("git fetch origin main --depth=1", Configuration.SourceCodeFolder, true, exitOnError: false);
-        var output = ProcessHelper.StartProcess("git diff --name-only origin/main -- \"*.cs\"", Configuration.SourceCodeFolder, true, exitOnError: false);
-        if (string.IsNullOrWhiteSpace(output)) return [];
-
-        var repoRoot = Configuration.SourceCodeFolder;
-        return output
-            .Split('\n', StringSplitOptions.RemoveEmptyEntries)
-            .Select(relativePath => Path.GetFullPath(Path.Combine(repoRoot, relativePath.Trim())))
-            .Where(fullPath => fullPath.StartsWith(solutionDirectory, StringComparison.OrdinalIgnoreCase) && File.Exists(fullPath))
-            .Select(fullPath => Path.GetRelativePath(solutionDirectory, fullPath))
-            .ToArray();
-    }
 }

developer-cli/Commands/LintCommand.cs

@@ -16,13 +16,15 @@ public class LintCommand : Command
         var cliOption = new Option<bool>("--cli", "-c") { Description = "Run developer-cli linting" };
         var selfContainedSystemOption = new Option<string?>("<self-contained-system>", "--self-contained-system", "-s") { Description = "The name of the self-contained system to lint (e.g., main, account, back-office)" };
         var noBuildOption = new Option<bool>("--no-build") { Description = "Skip building and restoring the solution before running linting" };
+        var changedOnlyOption = new Option<bool>("--changed-only") { Description = "Lint only .cs files changed against origin/main. Default is to lint the full solution. Recommended for routine local runs; CI always lints the full solution." };
         var quietOption = new Option<bool>("--quiet", "-q") { Description = "Minimal output mode" };
 
         Options.Add(backendOption);
         Options.Add(frontendOption);
         Options.Add(cliOption);
         Options.Add(selfContainedSystemOption);
         Options.Add(noBuildOption);
+        Options.Add(changedOnlyOption);
         Options.Add(quietOption);
 
         SetAction(parseResult => Execute(
@@ -31,12 +33,13 @@ public class LintCommand : Command
                 parseResult.GetValue(cliOption),
                 parseResult.GetValue(selfContainedSystemOption),
                 parseResult.GetValue(noBuildOption),
+                parseResult.GetValue(changedOnlyOption),
                 parseResult.GetValue(quietOption)
             )
         );
     }
 
-    private static void Execute(bool backend, bool frontend, bool developerCli, string? selfContainedSystem, bool noBuild, bool quiet)
+    private static void Execute(bool backend, bool frontend, bool developerCli, string? selfContainedSystem, bool noBuild, bool changedOnly, bool quiet)
     {
         var noFlags = !backend && !frontend && !developerCli;
         var lintBackend = backend || noFlags;
@@ -54,7 +57,7 @@ private static void Execute(bool backend, bool frontend, bool developerCli, stri
             if (lintBackend)
             {
                 Prerequisite.Ensure(Prerequisite.Dotnet);
-                hasIssues = RunBackendLinting(selfContainedSystem, noBuild, quiet);
+                hasIssues = RunBackendLinting(selfContainedSystem, noBuild, changedOnly, quiet);
                 backendTime = Stopwatch.GetElapsedTime(startTime);
             }
 
@@ -69,7 +72,7 @@ private static void Execute(bool backend, bool frontend, bool developerCli, stri
             if (lintDeveloperCli)
             {
                 Prerequisite.Ensure(Prerequisite.Dotnet);
-                var developerCliHasIssues = RunDeveloperCliLinting(noBuild, quiet);
+                var developerCliHasIssues = RunDeveloperCliLinting(noBuild, changedOnly, quiet);
                 hasIssues = hasIssues || developerCliHasIssues;
                 developerCliTime = Stopwatch.GetElapsedTime(startTime) - backendTime - frontendTime;
             }
@@ -119,10 +122,24 @@ private static void Execute(bool backend, bool frontend, bool developerCli, stri
         }
     }
 
-    private static bool RunBackendLinting(string? selfContainedSystem, bool noBuild, bool quiet)
+    private static bool RunBackendLinting(string? selfContainedSystem, bool noBuild, bool changedOnly, bool quiet)
     {
         var solutionFile = SelfContainedSystemHelper.GetSolutionFile(selfContainedSystem);
 
+        var includeArgument = string.Empty;
+        if (changedOnly)
+        {
+            var changedCsFiles = GitHelper.GetChangedCsFilesInDirectory(solutionFile.Directory!.FullName);
+            if (changedCsFiles.Length == 0)
+            {
+                if (!quiet) AnsiConsole.MarkupLine("[green]No changed C# files found, skipping backend linting.[/]");
+                return false;
+            }
+
+            includeArgument = $""" --include="{string.Join(";", changedCsFiles)}" """.TrimEnd();
+            if (!quiet) AnsiConsole.MarkupLine($"[blue]Linting {changedCsFiles.Length} changed file(s)...[/]");
+        }
+
         if (!noBuild)
         {
             if (!quiet) AnsiConsole.MarkupLine("[blue]Running backend code linting...[/]");
@@ -142,7 +159,7 @@ private static bool RunBackendLinting(string? selfContainedSystem, bool noBuild,
         // but those attributes are mandatory for cross-client email rendering and cannot be removed.
         // The dist folder is gitignored build output, not source.
         ProcessHelper.Run(
-            $"dotnet jb inspectcode {solutionFile.Name} --no-build --no-restore --output=result.json --severity=SUGGESTION --exclude=**/emails/dist/**",
+            $"dotnet jb inspectcode {solutionFile.Name} --no-build --no-restore --output=result.json --severity=SUGGESTION --exclude=**/emails/dist/**{includeArgument}",
             solutionFile.Directory!.FullName,
             "Linting",
             quiet
@@ -229,10 +246,24 @@ private static bool CheckMissingTranslations(bool quiet)
         return true;
     }
 
-    private static bool RunDeveloperCliLinting(bool noBuild, bool quiet)
+    private static bool RunDeveloperCliLinting(bool noBuild, bool changedOnly, bool quiet)
     {
         var solutionFile = new FileInfo(Path.Combine(Configuration.CliFolder, "DeveloperCli.slnx"));
 
+        var includeArgument = string.Empty;
+        if (changedOnly)
+        {
+            var changedCsFiles = GitHelper.GetChangedCsFilesInDirectory(solutionFile.Directory!.FullName);
+            if (changedCsFiles.Length == 0)
+            {
+                if (!quiet) AnsiConsole.MarkupLine("[green]No changed C# files found, skipping developer-cli linting.[/]");
+                return false;
+            }
+
+            includeArgument = $""" --include="{string.Join(";", changedCsFiles)}" """.TrimEnd();
+            if (!quiet) AnsiConsole.MarkupLine($"[blue]Linting {changedCsFiles.Length} changed file(s)...[/]");
+        }
+
         if (!noBuild)
         {
             if (!quiet) AnsiConsole.MarkupLine("[blue]Running developer-cli code linting...[/]");
@@ -248,7 +279,7 @@ private static bool RunDeveloperCliLinting(bool noBuild, bool quiet)
         }
 
         ProcessHelper.Run(
-            $"dotnet jb inspectcode {solutionFile.Name} --no-build --no-restore --output=result.json --severity=SUGGESTION",
+            $"dotnet jb inspectcode {solutionFile.Name} --no-build --no-restore --output=result.json --severity=SUGGESTION{includeArgument}",
             solutionFile.Directory!.FullName,
             "Linting",
             quiet

developer-cli/Utilities/GitHelper.cs

@@ -141,6 +141,24 @@ public static void FetchFromOrigin()
         ProcessHelper.StartProcess("git fetch origin", Configuration.SourceCodeFolder);
     }
 
+    // Returns relative paths (relative to solutionDirectory) of .cs files changed compared to
+    // origin/main. Fetches origin/main first so this works on shallow CI clones; the fetch is
+    // best-effort and silent on failure.
+    public static string[] GetChangedCsFilesInDirectory(string solutionDirectory)
+    {
+        ProcessHelper.StartProcess("git fetch origin main --depth=1", Configuration.SourceCodeFolder, true, exitOnError: false);
+        var output = ProcessHelper.StartProcess("git diff --name-only origin/main -- \"*.cs\"", Configuration.SourceCodeFolder, true, exitOnError: false);
+        if (string.IsNullOrWhiteSpace(output)) return [];
+
+        var repoRoot = Configuration.SourceCodeFolder;
+        return output
+            .Split('\n', StringSplitOptions.RemoveEmptyEntries)
+            .Select(relativePath => Path.GetFullPath(Path.Combine(repoRoot, relativePath.Trim())))
+            .Where(fullPath => fullPath.StartsWith(solutionDirectory, StringComparison.OrdinalIgnoreCase) && File.Exists(fullPath))
+            .Select(fullPath => Path.GetRelativePath(solutionDirectory, fullPath))
+            .ToArray();
+    }
+
     public static void StashChanges(string message = "Stashed by Developer CLI")
     {
         ProcessHelper.StartProcess($"git stash push -m \"{message}\"", Configuration.SourceCodeFolder);