[brettheap]

Lane: openreposhape-4 (openRepoShape-4)
Claim: #412 (comment)

What and why

An assembly root's scripts/validate-pins.py on a machine with no git ended in a FileNotFoundError traceback, exit 1. This file's own exit codes give 1 to "a FINDING: drift a reviewer can act on" and 2 to "the question could not be asked ... never an implicit pass", so a CI step or a person reading the code took a missing git for drift, though nothing was found. The doctor's pins row said so in its own words.

git_out raises FileNotFoundError when there is no git on PATH, PermissionError when the git found there will not run, and a plain OSError (ENOEXEC) when it cannot be executed (a binary for another architecture, a script with no shebang), and nothing in the validator caught any of them. The three calls that run git now run inside _git_runs, which refuses git-not-runnable, exit 2, naming the check and saying to put git on PATH and run scripts/validate-pins.py again:

• the leg's gitlink (recorded_gitlink): the spec leg's gitlink recorded at 'spec' could not be read;
• the pinned commit's lookup in the submodule (git_out): spec: the pinned commit <12 hex> could not be looked up in that submodule;
• the tree digest (tree_digest): spec: the tree digest at <12 hex> could not be recomputed.

The issue's own repro, at this head (validate-manifest.py runs no git and still passes):

validate-pins.py, git on PATH: exit 0      pins ok
validate-pins.py, no git: exit 2
REFUSED git-not-runnable: the spec leg's gitlink recorded at 'spec' could not be read: git could not be run (No such file or directory)
Remediation: put git on PATH and run `scripts/validate-pins.py` again. This assembly root's lockstep gate reads each leg's gitlink and recomputes its pinned tree digest through git, so without it nothing says whether the pins agree, and a gate that cannot answer is never a pass.

A git on PATH that is not executable says the same with (Permission denied), and one that cannot be executed with (Exec format error).

The rulings

1. WHERE: in this validator, not in git_out or repo_shape.py, as validate-family.py's default and --pins modes end in a FileNotFoundError traceback, exit 1 (a finding's code), when git is not on PATH: on main for every holder with a member (recorded_gitlink through repo_shape.git_out), and after #317 still for a holder whose .gitmodules is gone, though #317's own check answers gitmodules-unreadable, exit 2, whenever the file is there #368's fix did in validate-family.py. scripts/repo_shape.py is untouched, and the change adds nothing to the names this file imports from it, so a root whose repo_shape.py is older than this copy still imports it.
   • Only a git that will not start counts, told apart two ways. (a) The block is around the three git calls alone, never a whole check: the (submodule / ".git").exists() before them, a pin file or a workflow nobody may read stay exactly what they were. (b) Inside a git call the rule is the NAME subprocess gives the error: any OSError whose filename is git counts (a missing git, one that will not run, one that cannot be executed: ENOEXEC), and so does a FileNotFoundError or PermissionError whose filename is None, those two classes only (Windows' CreateProcess failures carry no filename, so None is required there). subprocess raises the same two classes when the DIRECTORY it was to run git in cannot be entered, and names that directory where a program that will not start names git. Probed on Linux, Python 3.12: no git on PATH gives FileNotFoundError with filename 'git'; a git that is not executable gives PermissionError, 'git'; a git file with no shebang gives OSError: [Errno 8] Exec format error, 'git'; a missing, unreadable or non-directory cwd gives the directory's path. Any other OSError (an EIO, an out-of-memory, a directory's own error, a nameless one of neither class) leaves the wrapper as it entered: no git-not-runnable, no remedy about PATH. validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's wrapper caught every OSError; see "Follow-ups".
   • recorded_gitlink's except Refusal does not turn the error into "no gitlink recorded". An OSError is no Refusal, so it passes straight through that clause and reaches _git_runs; there is no false pin-gitlink-absent. Tested both ways: test_a_missing_git_is_not_read_as_no_gitlink, and its control test_a_gitlink_the_root_does_not_record_is_still_pin_gitlink_absent (git runs, records nothing, the old refusal stands). The pinned commit's lookup has the same shape one step on: its own except Refusal would say pin-commit-unresolvable ("fetch that commit"), so _git_runs sits OUTSIDE its try (test_a_missing_git_is_not_read_as_an_unresolvable_commit, control test_a_commit_git_cannot_find_is_still_pin_commit_unresolvable).
2. ONE CODE: git-not-runnable, the code validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406 chose for the holder, so a project and a holder say the same thing. The wording is this validator's own (an assembly root, scripts/validate-pins.py, what to do) and uses no holder words. The module docstring's EXIT CODES now names it under 2.
3. LANDING. scripts/validate-pins.py is a pinned copy. It reaches existing roots through update-shape.py as upstream-changed, and nothing more is needed here. Checked with a root scaffolded from main 3ef059c and update-shape.py check --upstream <this checkout> (local path): upstream-changed scripts/validate-pins.py, unchanged on the other ten rows, nothing written.
4. THE DOCTOR is unchanged. Its pins row on a machine with no git, on a root scaffolded from main and on one scaffolded from this head:
   • main: FINDING pins the project's own scripts/validate-pins.py reports a finding (exit 1): FileNotFoundError: [Errno 2] No such file or directory: 'git';
   • this head: FINDING pins the project's own scripts/validate-pins.py refuses (exit 2): REFUSED git-not-runnable: the spec leg's gitlink recorded at 'spec' could not be read: git could not be run (No such file or directory).
   • No test matches the old traceback text: tests/test_shape_doctor.py and tests/test_doctor_legs_members_next.py hold no FileNotFoundError, No such file or [Errno 2] (the one [Errno 13] Permission denied is a hand-built placement row). tests/test_doctor_validator_rows.py is on main now (shape-doctor.py: a validator that crashed says it crashed instead of "reports a finding", and is CANNOT ANSWER when it is the standard's template, which a standard whose path holds the PYTHONPATH separator no longer runs at all; a neutral product's digest validate-pins.py skipped is a note naming the product, from a child that can no longer reach gh or a proxy; and a root whose manifest does not load and whose scripts/repo_shape.py is gone is told to restore that file before its gate (#278, #297, #298) #357 landed as 5678f68); its one Traceback assertion is about an injected RuntimeError: boom, and the file passes on the merge below.

Tests and mutants

tests/test_validate_pins_without_git.py, 58 tests, in process: the validator's own git_out and the one recorded_gitlink and tree_digest call inside repo_shape are patched to raise what a git that will not start raises, and no PATH is changed, so each test means the same on every OS. The fake takes **kwargs, so it keeps working if #406's env= lands on git_out, and it picks the call to fail by the git SUBCOMMAND (subcommand() skips git's global options and the value of -C/-c), never by args[0]: #406's recorded_gitlink runs git --literal-pathspecs ls-files ..., which the first draft's args[0] == "ls-files" stopped matching (Fix round 1, MUST-1).

• exit 2, the code and no Traceback, in each of three runs (plain, --quiet, --pin-source) and for each of five errors a git that will not start raises (missing, not executable, cannot be executed, and a FileNotFoundError and a PermissionError that name no file);
• each of the three calls named by the check it is, one failing at a time, for a missing git, a git that is not executable and one that cannot be executed;
• each of the three predicates picks its own call and no other with global options in front of the subcommand (--literal-pathspecs, -C <dir>, -c <k=v>), and the second gitlink listing is none of them;
• the two "not read as" tests above, each with its control where git runs;
• the same root through the same harness says pins ok (the control of the whole file);
• seven errors that are no git that will not start (an unreadable directory, a missing one, a non-directory, EIO, ENOMEM, an ENOEXEC that names no file, one that names a directory), at each of the three calls, leave the wrapper unchanged: the same exception object comes out and no git-not-runnable is said;
• one test with no fake, POSIX only: PATH names an empty directory and the real subprocess raises, so the exc.filename reading is checked against subprocess itself and not only against this change's picture of it. It skips on Windows, where the program search is not PATH's alone.

On main's validator 27 of the 58 fail (the 31 that pass are the controls, the predicate test and the seven non-git errors, which main passes through because it catches nothing).

Mutants, run on this head's bytes (scratch worktree, never committed), tests failing of 58:

mutant	failing
the OSError clause removed	27
any OSError counts as git not runnable	21 (every non-git case)
classes kept, the filename check dropped (a directory counts, and a git that cannot be executed does not)	12
OSError broad, filename not in (None, git) (a nameless error of any class counts)	9
the refusal exits 1 (every refusal / only this code)	29 / 27
the commit lookup's wrapper moved inside its try	4
the gitlink wrapper removed / the commit wrapper removed / the digest wrapper removed	20 / 4 / 3
recorded_gitlink (repo_shape.py) swallows OSError as it does Refusal	27
the remediation drops "put git on PATH"	25
Fix round 1: the new clause dropped (d4b371f's rule: FileNotFoundError/PermissionError only)	6
the nameless clause dropped (only filename git counts, Windows)	6
the nameless clause for FileNotFoundError only	3
ENOEXEC counted by its errno, whatever file it names	6
the test's gitlink predicate back to args[0] == "ls-files"	4 here, 15 on the merge with #406
the test's commit / digest predicate back to args[0]	4 / 4
subcommand() stops skipping the value of -C and -c	2

Every mutant is killed. Runs (identity exported, frvenv and a gh shim first on PATH, --basetemp carrying w412f, no GIT_ALLOW_PROTOCOL):

• at head b71f3fc, tests/test_validate_pins_without_git.py tests/test_pin_validator.py tests/test_neutral_pin_validator.py tests/test_scaffold_pin_and_reuse.py tests/test_agents_md_codes.py: 169 passed. (tests/test_doctor_validator_rows.py is not on this branch's base, 3ef059c.)
• on a scratch merge, never pushed, of origin/main dd8d0ea, validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's head e83cc21 and b71f3fc, the same five files and tests/test_doctor_validator_rows.py: 197 passed; this file alone: 58 passed.
• at d4b371f (before this round): the other files that run validate-pins.py and take minutes (test_repo_hygiene, test_cli_reference, test_validator_child_encoding, test_pin_rewrite_layout, test_scaffold_e2e, test_bump_leg, test_update_shape, test_update_shape_add, test_update_shape_landing, test_doctor_legs_members_next, test_scaffold_mount_ignored): 563 passed, 1 skipped (test_bump_leg.py::test_a_tracked_workflow_respelled_by_case_moves_under_gits_spelling); a scratch triple merge with validate-pins.py (assembly-root template): a workflow file under .github/workflows/ that is not UTF-8, or that this user cannot open, is ONE workflow-unreadable refusal naming every such file, exit 2, so the project's pins gate no longer ends in a UnicodeDecodeError traceback, exit 1, with no line naming the file (#359) #419 and scaffold-project.py, validate-pins.py, repo_shape.py: open-glass and open_glass share one SHAPE_PIN_SOURCE_<PRODUCT>, so --pin refuses the pair and validate-pins.py notes a declared one and reads the variable for neither (#275) #409: 304 passed. Not repeated at b71f3fc: this round changes the rule in _git_runs and the test file, and CI's three OSes are the gate.
• Left out: test_shape_doctor.py (over twenty minutes at this load, and no doctor code changed) and the test_adopt_*, test_family*, test_naming_policy and other test_scaffold_* files that only mention the script.

Fix round 1 (review of d4b371f)

• MUST-1, the test's gitlink predicate broke on a merge with validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406. The fake chose the call to fail by args[0] == "ls-files" (and "rev-parse", "ls-tree"). validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406 makes recorded_gitlink run git --literal-pathspecs ls-files -s -- <path> (GITLINK_LISTINGS), so on a merge with it the predicate never matched and 8 of the 38 tests failed (the "gitlink" cases); whichever of validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406 and this PR landed second would have gone red. Each predicate now reads the subcommand wherever it sits among git's global options, and a test of its own feeds each predicate the argv with options in front of it, so the file says so on its own head and not only on a merge. Proved both ways: this file passes 58 of 58 on this head and on a scratch merge of origin/main with validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's head; with the predicate put back to args[0] it fails 4 here and 15 on that merge. validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406 needs no change.
• NIT-1, a git that exists but cannot be executed (ENOEXEC) still ended in a traceback. A binary for another architecture or a script with no shebang makes subprocess raise a plain OSError whose filename is git, exit 1. The rule is now "any OSError whose filename is git, or a FileNotFoundError/PermissionError whose filename is None" (None kept for those two classes only, for Windows' CreateProcess). Every exclusion the tests pin stands. With a real git file with no shebang first on PATH, the run now ends REFUSED git-not-runnable: ... git could not be run (Exec format error), exit 2 (checked in scratch; the committed tests use the fake). Tests added: OSError(ENOEXEC, ..., "git") in every mode and at each of the three calls, a nameless PermissionError, an ENOEXEC that names no file and one that names a directory (neither is git); mutants above.
• NIT-2, this body. tests/test_doctor_validator_rows.py is on main (shape-doctor.py: a validator that crashed says it crashed instead of "reports a finding", and is CANNOT ANSWER when it is the standard's template, which a standard whose path holds the PYTHONPATH separator no longer runs at all; a neutral product's digest validate-pins.py skipped is a note naming the product, from a child that can no longer reach gh or a proxy; and a root whose manifest does not load and whose scripts/repo_shape.py is gone is told to restore that file before its gate (#278, #297, #298) #357 landed as 5678f68): the sentence that said it was not is corrected above, and the file is in the merge run. The wrapper's rule now covers ENOEXEC. validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's broader wrapper is to adopt this rule in a follow-up (its NIT-2); the lasting home for one shared wrapper is scripts/repo_shape.py.

Neighbours (git merge-tree --write-tree, head b71f3fc against each, origin/main dd8d0ea at the time)

branch	head	result
origin/main	dd8d0ea	clean
#343 fix/pin-files-not-a-list	9e6caeb	clean
#409 fix/pin-source-env-collisions	6494714	clean
#419 fix/validate-pins-workflow-not-utf8	11dff7f	clean
#406 fix/validate-family-unnamed-mounts	e83cc21	clean, and semantically: this file passes 58 of 58 on the merge (the argv prefix --literal-pathspecs is why the first draft did not, see MUST-1)

My first draft appended to the EXIT CODES line #419 re-wraps and conflicted with it; the sentence is now a pure insertion after that line (the commit was amended before it was pushed). The edits are the docstring, two imports, _git_runs (placed above _check_gitlink_matches_pin) and the three call sites; none is in _check_shape_pin, _workflow_refs or the neutral-pin functions.

Follow-ups (named, not done here)

• validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's _git_runs in validate-family.py catches any OSError (and wraps the whole of _check_member_tree); the review of 423fb25 (NIT-2) found it tells an operator with an unreadable members/<Project> to put git on PATH. validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's wrapper is to adopt this rule in a follow-up (validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's NIT-2): any OSError whose filename is git, or a FileNotFoundError/PermissionError with none. The lasting fix is ONE git_runs in scripts/repo_shape.py, which both gates receive, the remediation's subject a parameter; that waits for validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406 and scaffold-project.py, validate-pins.py, repo_shape.py: open-glass and open_glass share one SHAPE_PIN_SOURCE_<PRODUCT>, so --pin refuses the pair and validate-pins.py notes a declared one and reads the variable for neither (#275) #409 to clear repo_shape.py.
• On Windows a git that cannot be executed raises OSError [WinError 193] from CreateProcess with no filename, which is neither of the two classes the nameless clause counts, so it is not counted here (a reading of CPython, not run on Windows; the ruling keeps None for those two classes).
• _digest_from_source (a neutral product's --pin-source) keeps its own except OSError and is left alone: it is reached only after every leg's gitlink was read, so with no git the refusal above comes first.
• On a machine with no git the doctor's other rows (shape currency, legs) still read could not be run: [Errno 2] ... 'git', and the verdict reads DRIFTED (1 leg(s) not at the pin); scripts/bootstrap.py in an assembly root ends in the same traceback, exit 1. Neither is this file.
• A leg's submodule directory nobody may enter (mode 000, git running) still ends in a PermissionError traceback, exit 1, out of (submodule / ".git").exists() in _check_pin_digest (probed on Python 3.12; the same exit-code defect as The assembly root's scripts/validate-pins.py ends in a FileNotFoundError traceback, exit 1, a finding's code, when git is not on PATH, because recorded_gitlink reaches repo_shape.git_out and nothing catches OSError, where the file's own exit codes give 1 to drift and 2 to a question that could not be asked: the sibling of #368, whose fix is ruled into validate-family.py only #412, a different cause). That is the case validate-family.py: a gitlink in members/ or a .gitmodules section whose path no row names is a finding in every mode, a hand-edited path: is member-path with nothing read through it and recorded_gitlink reads its path literally, and no git to run refuses git-not-runnable instead of a traceback that exits 1 (#361, #367, #368) #406's review found its wrapper mislabelling, and here it is deliberately NOT git-not-runnable; what it should be is a separate decision. A pin file nobody may read is already yaml-unreadable, exit 2, and an unreadable workflow is validate-pins.py (assembly-root template): a workflow file under .github/workflows/ that is not UTF-8, or that this user cannot open, is ONE workflow-unreadable refusal naming every such file, exit 2, so the project's pins gate no longer ends in a UnicodeDecodeError traceback, exit 1, with no line naming the file (#359) #419's.

Closes #412

🤖 Generated with Claude Code

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 4 hours and 48 minutes by commenting @sourcery-ai review. Upgrade to get a review now.

[sourcery-ai]

Reviewer's Guide

The validator now catches only failures that prevent git itself from starting, reports them uniformly as the existing exit-2 git-not-runnable refusal with actionable, check-specific diagnostics, and adds targeted tests to protect classification, error propagation, and existing behavior.

Sequence diagram for validate-pins git-not-runnable handling

sequenceDiagram
    participant Validator as validate-pins.py
    participant Gitlink as recorded_gitlink
    participant Git as git_out
    participant Digest as tree_digest
    participant Refusal as Refusal

    Validator->>Gitlink: recorded_gitlink(root, path)
    Gitlink-->>Validator: gitlink or OSError
    alt git cannot start
        Validator->>Refusal: _git_runs converts FileNotFoundError/PermissionError
        Refusal-->>Validator: git-not-runnable, exit 2
    else gitlink is absent
        Validator->>Refusal: pin-gitlink-absent
    end

    Validator->>Git: git_out(rev-parse, cwd=submodule)
    Git-->>Validator: commit lookup result
    alt git cannot start
        Validator->>Refusal: _git_runs converts startup error
        Refusal-->>Validator: git-not-runnable, exit 2
    else commit cannot be resolved
        Validator->>Refusal: pin-commit-unresolvable
    end

    Validator->>Digest: tree_digest(submodule, commit)
    Digest-->>Validator: digest or startup error
    alt git cannot start
        Validator->>Refusal: _git_runs converts startup error
        Refusal-->>Validator: git-not-runnable, exit 2
    else digest differs
        Validator-->>Validator: report pin-digest-mismatch
    end

Loading

Flow diagram for classifying git execution failures

flowchart TD
    A["Run one git-dependent operation"] --> B{"FileNotFoundError or PermissionError?"}
    B -- No --> C["Propagate the original error"]
    B -- Yes --> D{"exc.filename is git or absent?"}
    D -- No --> C
    D -- Yes --> E["Raise git-not-runnable refusal"]
    E --> F["Exit 2 and name the unread check"]
    F --> G["Remediation: put git on PATH and rerun validate-pins.py"]

Loading

File-Level Changes

Change	Details	Files
Translate git startup failures into an explicit exit-2 refusal instead of an uncaught traceback or a misleading pin finding.	Add a context manager that recognizes only FileNotFoundError or PermissionError referring to git (or no filename). Emit the single git-not-runnable code with check-specific diagnostics and PATH remediation. Wrap the gitlink, pinned-commit lookup, and tree-digest calls while preserving existing refusal handling and exit behavior for other OSErrors. Document git-not-runnable among the validator's exit-2 refusal codes.	templates/assembly-root/scripts/validate-pins.py
Add comprehensive regression coverage for missing or non-executable git and distinguish it from unrelated filesystem failures.	Test exit 2, no traceback, consistent remediation, and check-specific messages across validator modes and all three git call sites. Verify missing git is not misclassified as an absent gitlink or unresolvable commit, while controls preserve those existing refusals when git runs. Verify directory and unrelated OSError failures pass through unchanged, and exercise a real PATH-based missing-git subprocess failure. Cover the successful pins-ok path and parameterize missing-git error forms and invocation modes.	tests/test_validate_pins_without_git.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#412	When validate-pins.py cannot start git for a git-backed check, report a refusal with exit code 2 and code git-not-runnable, rather than a traceback that exits 1.	✅
#412	Apply the refusal consistently to the gitlink, pinned-commit lookup, and tree-digest checks, while preserving their existing findings and refusals when git runs or when an error is unrelated to starting git.	✅

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud