[brettheap]

Lane: openreposhape-5 (openRepoShape-5)
Claim: #391 (comment)

What was wrong

templates/assembly-root/scripts/bootstrap.py main opened with print(f"bootstrap: {name} ({root})"), before any step ran, and templates/family-root/scripts/bootstrap.py with the same line (:180, with a literal dash in it).

• name: "a\ud83db" reads as a string holding a lone surrogate, which no UTF-8 stdout can write. scripts/bootstrap.py exited 1 with UnicodeEncodeError, make bootstrap exited 2, and validate-manifest.py, the validator that names the problem, was never reached.
• 日本 under PYTHONIOENCODING=ascii ended the same way.
• The family root's line holds a literal —, so under that stdout it raised for EVERY name (InkRouter included). The assembly root's own wording has the same dash in two lines and a middle dot in the register readout.
• A raw ESC or CR in a name is encodable on every stdout and reached the terminal as the control it is (bootstrap: a^[b^Mc (...)).

Both files are shape copies, digest-pinned in the project that holds them, and a project carries scripts/repo_shape.py and no shape_materialize.py, so neither can call #214's helper. Both already import Refusal, find_repo_root and load_yaml from that repo_shape.py.

What the fix does

scripts/repo_shape.py, the pinned shared library every project and every family holder carries beside its bootstrap.py, gains two functions and the two sets one of them reads (a new section at its end, scripts/repo_shape.py:2524). Both roots' bootstrap.py import the two functions on the from repo_shape import line they already had, and define neither:

• escape_unencodable_stdout() is the first statement of each root's main. A strict or surrogateescape stdout becomes backslashreplace, the handler stderr already has: what the stdout holds is written as it was, what it cannot hold as \u65e5. Any other handler is left alone and the encoding is never changed. It is validate-pins.py's guard from templates/assembly-root/scripts/validate-pins.py: a bare --pin-source <path> whose path holds an = is read as <product>=<path> (raw.partition("=")), so a stand-in clone under a directory named a=b is never consulted and the pin's digest silently goes to gh api and a skip (pins ok, exit 0), or, when the text before the = is a declared pin's name, to a FileNotFoundError traceback #295 (validate-pins.py:851), which is inline there and cannot be imported.

• spelled(value) writes the escape Python spells (\x1b, \r, \n, \u2028, \ud83d, \u202e) for EXACTLY four kinds of character, chosen by Unicode category and not by str.isprintable:

  • the controls (Cc: C0, DEL and C1);
  • the surrogates (Cs);
  • the line and paragraph separators (Zl, Zp: U+2028 and U+2029);
  • the bidirectional controls: U+061C, U+200E, U+200F, U+202A to U+202E and U+2066 to U+2069.

  Every other character prints as it did before this change: the zero-width non-joiner (U+200C) a Persian name needs, the zero-width joiner (U+200D) of an emoji sequence, the ideographic space (U+3000) of 山田 U+3000 太郎, the no-break space (U+00A0), the soft hyphen (U+00AD), any other format, space or unassigned character, and a backslash. The four categories are fixed ranges, so the answer does not move with the interpreter's Unicode database; unicodedata is the standard library's.

Helper decision: repo_shape.double_quoted / _escaped (scripts/repo_shape.py:347, :371) was read first and still cannot serve: it quotes and escapes " and \, so a plain printable name would not stay byte-identical. The two new helpers now live beside it, in the same file, the one library both roots import from. shape_materialize.escape_what_stdout_cannot_encode is in no project; shape_advisory.printable flattens to ? and is in no copy list.

Every print of a value the script read from the manifest, a register row or the disk is spelled:

• assembly root: the name and the root (first line); a leg's role, path and tracking branch in step (a); a register row's holder, act, objects, state and expiry, the register's path, and the reader's reason when it cannot be read.
• family root: the name and the root (first line), a member's project and directory name, --members-make (heading and failure line). The member's own command is still handed the RAW target.

A plain name prints exactly what it printed before: the new tests spell out the whole output of a plain project and a plain holder, and that golden also passes on the base. So does every valid name that holds one of the characters kept raw above (see the tests).

Files

• scripts/repo_shape.py: escape_unencodable_stdout(), spelled(), ESCAPED_CATEGORIES and ESCAPED_BIDI_CONTROLS, in a new section after die(); import unicodedata; one bullet in the module docstring's "WHAT THIS MODULE OWNS".
• templates/assembly-root/scripts/bootstrap.py and templates/family-root/scripts/bootstrap.py: both names on the existing from repo_shape import line (the family root's becomes the parenthesised form); escape_unencodable_stdout() first in main; every print of a value read from the manifest, a register row or the disk goes through spelled. Against origin/main each differs in nothing else.
• tests/test_bootstrap_spelling.py (new).

docs/cli.md is unchanged: no --help text moved.

Fix round 1 (review of 118c85a)

The first head's spelled wrote as an escape every character str.isprintable refuses. Independent review (its S1) showed that is wider than controls, surrogates and line separators: it also refuses every space but ASCII space, every format character and every unassigned code point, so a valid name that validate-manifest.py accepts and prints raw on the very next lines was escaped by this script's first line (a Persian name with its ZWNJ, an emoji sequence with its ZWJ, 山田 U+3000 太郎, a no-break space, a soft hyphen). The printed git submodule update --init <path> command was then wrong to paste for such a leg path, and what was escaped moved with the interpreter's Unicode database (Python 3.9 ships Unicode 13, 3.12 ships 15). The claim "prints byte for byte" was false for those names.

The coordinator decided, and Brett may reverse it: escape by category, not by str.isprintable, the four kinds listed above. Everything else prints raw, as on the base. The bidirectional controls stay escaped on purpose, so a name cannot reorder the text around it on a terminal. The alternative the review offered, and this does not take, is to keep isprintable, correct the claims, and pin ZWNJ and U+3000 as escaped by a test row.

The other round-1 changes: the lone-surrogate rows now assert FINDING manifest-name and no Traceback unconditionally, since #280 landed in #390 (cb7063f), and the make bootstrap row asserts there is no Traceback either; the docstrings, the test module's docstring and the unit rows say what is escaped and what is not. The branch has merged origin/main (53bee5b, which carries #390); the merge touched neither bootstrap file.

Fix round 2 (CI and SonarCloud)

• CI (2733c6a). The test module loaded each root's bootstrap.py through importlib, which wrote templates/*/scripts/__pycache__/bootstrap.cpython-*.pyc, and tests/test_scaffold_leg_path_collisions.py, which reads every file of the assembly template as UTF-8, then failed on it. load() now sets sys.dont_write_bytecode around the load, and a regression test asserts that loading either root, from the tree and from a copy in an empty directory, leaves no file behind.
• SonarCloud (d0aea3e). The quality gate failed on duplication, 14.7% on new code against 3%: spelled() and escape_unencodable_stdout(), with the two sets, were written out once in each root, and a test held the two copies identical. The premise for the copies, that a root cannot import anything of this repository's, was false: both bootstraps already import from scripts/repo_shape.py, which every project and every family holder carries. Brett Heap decided to move the two helpers into repo_shape.py and have both roots import them, with no Sonar exclusion. The code moved byte for byte (the AST of each function and set, docstrings aside, equals both old copies); only the docstring sentences the move made untrue are reworded. The new section, import unicodedata after import sys, and the docstring bullet after Refusal sit where none of the open pull requests that also edit repo_shape.py edits: 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, validate-repository-naming.py, repo_shape.py: a --link-source value is PRODUCT=PATH only when its key names a chain link, and a link source that cannot be entered is a WARNING with the system's reason, not a traceback (#338) #453 and adopt-project.py: execute records in project.yaml which leg the plan gave each submodule a leg keeps, and shape-doctor.py holds the submodule to that row, so one in the other leg is MISPLACED and a real adoption's placement reads ok (#189) #394 each merge with this head with no conflict, in that file or any other (git merge-tree --write-tree against each branch's head, 2026-10-12). family.py: bump and remove put the holder back when a hook, a lock or git refuses them after they write, and say what they put back or what is left with the commands that put it back; they ask first what their dry runs ask first; and remove refuses a held index.lock before it unmounts and a .gitmodules that gives the member's path to two submodules, of which git rm took out one (#365, #360) #416 landed as 580d7df without touching repo_shape.py.
• The branch merged origin/main ec8e09a (e4b0386) first; that merge touched none of this pull request's files. git merge-tree --write-tree of this head with current main is clean (2026-10-12).

How it was tested

tests/test_bootstrap_spelling.py (new, 205 tests at this head, local bare remotes, no gh). Answered in bytes, stdout decoded strictly in the encoding the run was given (stderr with replace), under utf-8:strict, utf-8:surrogateescape, cp1252:surrogateescape, cp1252:strict, ascii:strict and utf-8:replace:

• name rows in a real scaffolded project and a real family holder:
  • spelled: plain, lone surrogate, ESC and CR, 日本, newline/tab/DEL, U+2028, the right-to-left override (U+202E) with the right-to-left mark (U+200F), an emoji, a quote and a backslash, two lone surrogates;
  • kept raw, as on the base: a no-break space (on all six stdouts, the cp1252 ones hold it), a Persian name with its ZWNJ, an emoji sequence with its ZWJ, 山田 U+3000 太郎, a soft hyphen, a zero-width space with a byte-order mark. For each, the first line is compared in BYTES with what the plain print it replaced wrote (assembly and family), and a full run with the validators shows the validator's own manifest ok: <name> line raw beside it;
• every other print above: a leg's role, path and tracking branch (and the four lines that name a branch, one with a remote-tracking ref elsewhere), a register row, a register's path and the reader's reason, the root's own directory name in both roots, a member row and --members-make (with MAKE the interpreter, so a member runs only if the RAW target reached it);
• the run reaches the validators: a lone-surrogate name prints FINDING manifest-name, make bootstrap exits 2 and bootstrap FAILED: manifest (exit 1), with no Traceback and no frame in bootstrap.py;
• spelled and escape_unencodable_stdout directly, in repo_shape itself, once rather than once per root: every code point swept once against a set written from the specification (explicit ranges), which is itself checked against unicodedata.category; that each root's from repo_shape import names both and that neither root defines or assigns either function or either set (an ast check of the file); that the name each root's module exposes IS repo_shape's object; that the reconfigure is main's first statement; and that loading a root writes no bytecode under templates/.

The end-to-end rows run a real scaffolded project and a real family holder, and each carries scripts/repo_shape.py, so they run the moved code where it ships.

Results (Python 3.12.3, Linux; head d0aea3e = the move, on e4b0386 = the merge of origin/main ec8e09a):

run	result
test_bootstrap_spelling.py, test_scaffold_leg_path_collisions.py, test_stdout_encoding.py, test_template_quoted_values.py, test_template_values_single_pass.py, test_repo_hygiene.py, test_agents_md_codes.py	684 passed, 1 skipped (tests/test_stdout_encoding.py:286, Windows-only)
the five test_yaml_*.py, the six test_update_shape*.py, test_scaffold_e2e.py, test_family.py, test_validate_family_unnamed_mounts.py, test_cli_reference.py, test_windows_paths.py	706 passed, 3 skipped (tests/test_update_shape_add_symlink.py:831, NTFS junctions)
mutation: repo_shape.spelled escapes nothing	61 failed, 144 passed: 29 unit rows (every escape row, the code-point sweep, the non-string and one-line rows) and 32 end-to-end rows in a scaffolded project and a family holder (the name lines, a leg's role and path, a branch, a register row and a register's path, the root's directory, the member rows)
test_bootstrap_spelling.py again, the mutation reverted	205 passed

Earlier heads, not re-run on this one: on af26b19 the then 260-test file gave 197 failed, 63 passed against the base (cd1fc79) templates, 59 failed with both copies' spelled reverted to str.isprintable, and caught all 12 mutations of the category sets; reverting each hunk of the first round's fix, one at a time, still failed a new test (34 mutations, listed in the report); on 118c85a the existing bootstrap, scaffold, adopt, update-shape and doctor tests gave 496 passed, 1 skipped, and 305 passed. macOS and Windows have not run here; CI runs them on this head. Every new test reads and writes bytes and compares against project.resolve().

What the rest of the run says (the lone-surrogate and make bootstrap rows assert it at this head): a lone-surrogate name prints bootstrap: a\ud83db (<root>), reaches step (b), and ends

FINDING manifest-name: name is 'a\ud83db', which holds U+D83D, a lone surrogate: no UTF-8 file, commit message or console can hold it. ...
bootstrap FAILED: manifest (exit 1)

exit 1 (make bootstrap 2), with no Traceback on a pipe, a TTY or make.

What is left out

• The validators' own stdout. validate-manifest.py's manifest ok: <name> still prints through a stdout with no handler: a valid 日本 under ascii ends in ITS traceback (the issue's "Not in this issue"), and an ESC or CR name is accepted and the line writes the raw control.
• A manifest value that is passed to git rather than printed: tracking_branch: "a\ud83db" (or a leg's branch:) raises from subprocess inside step (a), before the validators; a NUL does too (ValueError: embedded null byte). Reproduced on origin/main 53bee5b. validate-manifest.py never reads either key, so it accepts the manifest (manifest ok, exit 0) and NO tool names the value. Not a print; follow-up below.
• stderr: print(str(exc), file=sys.stderr) (Refusal text built by repo_shape, multi-line, manifest text repr-escaped; stderr cannot raise) and the family's FETCH INCOMPLETE text (git's own words).
• templates/family-root/scripts/siblings.py, which carries the SAME first line twice (:676 in dispatch_all, :906 in _run_placement) with the same plain print, and prints member rows raw. make siblings, make park and make resume on name: "a\ud83db" still end in a UnicodeEncodeError traceback (reproduced on origin/main), and under PYTHONIOENCODING=ascii they end so for every name (the literal dash). It already imports from repo_shape, where both helpers now are, so they are two more names on its existing import line. Follow-up below.
• Behaviour that differs from the base, all deliberate:
  • a control, a surrogate, a line or paragraph separator or a bidirectional control in a value now prints as its escape where the base wrote it raw, so a Hebrew or Arabic name that holds an explicit U+200E, U+200F or U+061C prints \u200f for it;
  • a root path holding a byte that is not UTF-8 prints \udcXX where the root bootstrap shim's adopt-project.py plan raises UnicodeEncodeError in its terminal report, after the plan file is written, for a printable name stdout cannot encode (日本.md under cp1252, as on a redirected Windows stdout), so plan exits 1 before plan written to #214 handler wrote the raw byte back;
  • a name holding the four characters \x1b prints as one holding ESC does;
  • the wording's dash and middle dot print \u2014 and \xb7 on a stdout that cannot hold them, instead of raising.
• The digest: no digest of either bootstrap or of repo_shape.py is recorded in this repository. The scaffold, family.py init and adopt compute each files: row from the bytes they write, and update-shape.py compares upstream blobs at two commits. A project scaffolded from origin/main 580d7df, checked against this head (d0aea3e), reads upstream-changed for scripts/bootstrap.py and scripts/repo_shape.py and nothing else (assembly root: 2 changed, 9 unchanged; family holder: 2 changed, 8 unchanged). apply copies both and re-pins, the project's own validators say 11 copied shape file(s) match their digests (the holder's, 10), each copy equals its upstream blob, and scripts/bootstrap.py runs. Run for real, local remotes only.
• Compatibility: a project that keeps a locally edited scripts/repo_shape.py (check reads it both, and update-shape.py apply --accept-local scripts/repo_shape.py keeps the project's bytes) while taking the new bootstrap.py meets an ImportError the next time it bootstraps: scripts/bootstrap.py ends in cannot import name 'escape_unencodable_stdout' from 'repo_shape', exit 1. Following check's own instruction avoids it: check says to merge upstream's bytes into the edited file by hand, commit it, and only then apply --accept-local, and a merge that takes the new section brings both names. A project that skips the merge gets the error and nothing reports the break after apply: its validators still pass, because they import neither name; check then reads everything unchanged; and the project's validate.yml never runs bootstrap.py, so its CI stays green. The first command to fail is the one run after git clone. Guarding it is an item on Tracking: update-shape.py and bump-leg.py, keeping a project's shape copies and leg pins current #458's checklist (Tracking: update-shape.py and bump-leg.py, keeping a project's shape copies and leg pins current #458 (comment)): apply would refuse a kept --accept-local copy that lacks a name another copied shape file imports from it. It is the same coupling as the names the bootstraps already import from that file. Run for real on a project scaffolded from 580d7df.

Follow-ups found by lane 5's review of this branch, each reproduced on origin/main and filed separately:

• siblings.py's two first-line prints (and its member rows): make siblings, make park and make resume on a lone-surrogate family.yaml name end in a UnicodeEncodeError traceback (family-root siblings.py: make siblings, park and resume print the family's name with a plain print, so name: "a\ud83db" ends each in a UnicodeEncodeError, and the literal dash ends every name under PYTHONIOENCODING=ascii #454).
• A lone surrogate or a NUL in tracking_branch (or a leg's branch:) ends make bootstrap in a subprocess traceback in step (a), and validate-manifest.py accepts the manifest (assembly-root bootstrap.py: a lone surrogate or NUL in tracking_branch (or a leg's branch:) ends make bootstrap in a subprocess traceback in step (a), and validate-manifest.py says manifest ok, so no tool names it #455).
• family-root siblings.py: make siblings, park and resume print the family's name with a plain print, so name: "a\ud83db" ends each in a UnicodeEncodeError, and the literal dash ends every name under PYTHONIOENCODING=ascii #454 and assembly-root bootstrap.py: a lone surrogate or NUL in tracking_branch (or a leg's branch:) ends make bootstrap in a subprocess traceback in step (a), and validate-manifest.py says manifest ok, so no tool names it #455 (open, off the milestone) and the two Tracking: setup, scaffold, family and the shared helpers, creating projects and families #459 checklist items moved from bootstrap.py, the assembly root's template and the family holder's, ends in a FileNotFoundError traceback, exit 1, when git is not on PATH, because the root's step (a) calls recorded_gitlink, its offline upstream notice calls _try_git and the holder's step (a) runs git submodule update, and nothing catches OSError, where the docstrings say step (a) "never raises" and the notice "is silent when it cannot answer", so the first command a new engineer runs after cloning answers a missing git with a stack trace and the code its own bootstrap FAILED line uses: the third sibling of #368 and #412 #463 and scripts/validate-repository-naming.py, a pinned copy in every project, ends in a UnicodeEncodeError traceback, exit 1, when it prints a name that is not UTF-8 (--explain and the plain listing, under a strict UTF-8 stdout such as the one the doctor gives its children) and in a UnicodeDecodeError when it reads one from stdin, though --quiet answers the same name with FINDING naming-unclassified, so a directory made on a Latin-1 machine gets a crash where the script's own exit codes give 1 to a name that matches no family and 2 to a question that could not be asked #464 can import spelled and escape_unencodable_stdout from repo_shape.py, wherever they print a value.

Closes #391

🤖 Generated with Claude Code

[brettheap]

(lane openRepoShape-5, 2026-10-12T19:28Z) @codex review

[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 1 day and 23 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your settings.

[sourcery-ai]

Reviewer's Guide

Both bootstrap templates now avoid stdout encoding tracebacks and terminal control injection by safely configuring stdout and spelling only hazardous Unicode in values they print, while preserving raw values for operations and adding extensive cross-encoding regression tests.

Sequence diagram for encoding-safe bootstrap output

sequenceDiagram
    participant User
    participant Bootstrap
    participant Stdout
    participant Validator

    User->>Bootstrap: main(argv)
    Bootstrap->>Stdout: escape_unencodable_stdout()
    alt strict or surrogateescape handler
        Bootstrap->>Stdout: reconfigure(errors=backslashreplace)
    else other handler
        Bootstrap->>Stdout: keep encoding and handler
    end
    Bootstrap->>Bootstrap: spelled(manifest values)
    Bootstrap->>Stdout: print escaped hazardous values
    Bootstrap->>Validator: run validation steps
    Validator-->>Bootstrap: report finding without bootstrap traceback

Loading

Flow diagram for spelling bootstrap output values

flowchart TD
    A[Value read from manifest register or disk] --> B{Hazardous character?}
    B -->|Cc Cs Zl Zp or bidi control| C[Convert with unicode_escape]
    B -->|Any other character| D[Preserve raw character]
    C --> E[Print value]
    D --> E
    E --> F[Continue bootstrap and reach validators]

Loading

File-Level Changes

Change	Details	Files
Add shared stdout-safety and terminal-safe value rendering to both bootstrap template copies.	Reconfigure strict or surrogateescape stdout to backslashreplace without changing encoding or overriding other handlers. Escape controls, surrogates, line separators, and bidirectional controls by fixed Unicode categories/ranges while preserving all other characters byte-for-byte. Keep the helper implementations and escape constants identical across assembly and family roots.	templates/assembly-root/scripts/bootstrap.py templates/family-root/scripts/bootstrap.py
Apply safe rendering consistently to bootstrap output while preserving raw values for subprocess and filesystem operations.	Spell manifest names, root paths, leg roles/paths/branches, register values and paths, family member fields, and member targets wherever they are printed. Continue passing raw branch and make-target values to git and member subprocesses. Ensure stdout protection runs as the first statement of each main function.	templates/assembly-root/scripts/bootstrap.py templates/family-root/scripts/bootstrap.py
Add comprehensive encoding and behavioral coverage for both bootstrap variants.	Exercise names and printed fields across multiple encodings and error handlers, including lone surrogates, controls, bidirectional characters, non-printable-but-valid Unicode, and unencodable text. Verify validator and make-bootstrap failures are reported without bootstrap tracebacks and that plain/raw-safe output remains byte-identical. Cross-check the exact Unicode escape specification, stdout reconfiguration behavior, duplicated helper source, and main initialization order.	tests/test_bootstrap_spelling.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#391	Prevent the assembly-root bootstrap from crashing while printing a lone-surrogate name or a valid name its stdout cannot encode, so the run can reach the validators.	✅
#391	Apply the same stdout-encoding protection to the family-root bootstrap.	✅
#391	Keep the fix self-contained in both template copies without importing shape_materialize.	✅

Possibly linked issues

• templates/assembly-root/scripts/bootstrap.py and templates/family-root/scripts/bootstrap.py: main prints the manifest's name with a plain print before any step runs, so name: "a\ud83db" (a lone surrogate) ends make bootstrap in a UnicodeEncodeError traceback, exit 1 (make: 2), and the validator that names the problem is never reached; a valid name the stdout cannot encode ends the same way #391: The PR fixes the issue by reconfiguring strict stdout handlers and escaping unsafe characters in both bootstrap templates, allowing validation to run.

---

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
15 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