Stack profiles
The concrete tools and settings behind the baseline for each stack. Settings marked “ratchet” start with a baseline or allowlist for existing code that may only shrink. Tool names and flags reflect the tools as of 2026; verify them against the installed version.
Each profile names the rules that check it. Most are implementations of a capability: lint/configured/go is the Go implementation of lint/configured. Where a stack has no implementation of its own, the stack-neutral any implementation checks it if there is one (osv-scanner for vulnerabilities, a coverage gate, SOURCE_DATE_EPOCH); otherwise the capability reports no implementation for <stack>. The capability matrix shows the whole picture. Stack detection is catalog data too, see stacks.
Go
- Toolchain: pin with the
toolchaindirective ingo.mod. Task runner: Makefile. - Format:
gofumpt+goimports(via golangci-lint formatters). - Lint:
golangci-lintv2 withversion: "2"config. The configurationfleetlint fix --applywrites enableserrcheck,govet,staticcheck,unused,ineffassign,errorlint,nilerr,bodyclose,noctx,gosec,revive,gocognit(15),funlen(60 lines, 40 statements),exhaustive,unparam,godoxandnolintlint(an explanation on every//nolint);lint/strict/gorequireserrcheck,govet,staticcheck,errorlint,gosec,gocognitandfunlen. Worth adding:wrapcheck,contextcheck,forbidigo(banfmt.Print*andlog.Print*outside main/output),depguard(layer import rules). Usenew-from-revas the ratchet. - Errors: wrap with
fmt.Errorf("op: %w", err); inspect witherrors.Is/errors.As; sentinel or typed errors for expected cases. Nopanicin library code. Never_ =an error without a comment. - Design:
cmd/<app>+internal/; define small interfaces at the consumer; accept interfaces, return structs.context.Contextis the first parameter of every IO function; no contexts stored in structs. - Tests: stdlib
testing+go-cmp(testify optional); table-driven tests witht.Runandt.Parallel();httptestfor HTTP;testcontainers-gofor databases; native fuzzing (go test -fuzz) for parsers. Rungo test -race -shuffle=on ./.... - Coverage:
go test -coverprofile=cover.out -coverpkg=./...; convert to Cobertura (gocover-cobertura) fordiff-cover. - Logging:
log/slogwith a JSON handler; implementslog.LogValueron secret types to redact them. - Audit:
govulncheck ./...,go mod tidy -diff,gitleaks. - Licenses:
go-licenses check ./... --allowed_licenses=<allowlist>. - Slop guards:
godox(TODO/FIXME only with an issue reference),duplfor duplication,gremlinsfor mutation testing. - Benchmarks:
go test -run=^$ -bench=. -benchmem -count=10saved to a file; compare withbenchstatagainst the stored baseline. - API compatibility (libraries):
goreleasereports incompatible changes and suggests the next version. - Reproducible builds:
-trimpath, and GoReleaser’smod_timestamp. - Checked by:
format/configured/go,lint/configured/go,lint/strict/go,repo/toolchain-pinned/go,repo/lockfile-committed/go,deps/locked-install/go(no-mod=mod),deps/vulnerability-scan/go,deps/unused-check/go,deps/license-check/go,quality/coverage-threshold/go,release/reproducible-build/go.types/strictdoes not apply: the compiler is the type checker.
Python
- Toolchain:
uvfor Python version, venv and lockfile (uv.lock);pyproject.tomlonly; src layout. Task runner: Makefile (recipes calluv run ...). - Format + lint:
ruff format;ruff checkwith a broad selection:E,W,F,I,B,UP,SIM,C4,BLE,TRY,EM,S,PL,PT,RET,ARG,PTH,DTZ,T20,ERA,RUF,C90,ANN. Setmax-complexity = 15andPLR0915(max statements). Ratchet existing violations withruff check --add-noqarun once (it writes targeted# noqacodes), then shrink that set phase by phase. - Types:
mypy --strictorbasedpyrightin strict mode. NoAnyat module boundaries. - Errors: a project exception hierarchy rooted in one base class;
raise ... from err; no bareexcept:orexcept Exception: pass(BLE/S110 enforce this). - Design:
pydantic(orattrs/dataclasses + explicit validation) at boundaries;typing.Protocolfor ports;import-lintercontracts for layers. - Tests:
pytest,pytest-randomly,pytest-xdist;hypothesisfor parsing/logic;respx(httpx) orresponses(requests) for HTTP;time-machinefor clock;testcontainersfor DBs. Fixtures inconftest.py, builders intests/support/. - Coverage:
pytest --cov --cov-branch --cov-report=xml+diff-cover. - Logging: stdlib
loggingorstructlog;pydantic.SecretStrfor secrets. - Audit:
pip-audit(oruvwith osv-scanner),deptry(unused/missing deps),gitleaks. - Licenses:
pip-licenses --allow-only="<allowlist>". - Slop guards: ruff
TD(TODOs need an issue link, TD003),FIX,ERA(commented-out code) andT20(print);jscpdfor duplication;mutmutfor mutation testing. - Benchmarks:
pytest-benchmarkwith--benchmark-autosaveand--benchmark-compare --benchmark-compare-fail=mean:10%. - API compatibility (libraries):
griffe check <package>against the last release tag. - Checked by:
format/configured/python,lint/configured/python,lint/strict/python(ruff selects E, F, I, B, UP, SIM, BLE, S, C90, T20),types/strict/python(mypy or pyright strict),repo/toolchain-pinned/python,repo/lockfile-committed/python(an unhashedrequirements.txtis not a lockfile),deps/locked-install/python,deps/vulnerability-scan/python,deps/unused-check/python,deps/license-check/python,quality/coverage-threshold/python. Reproducible builds:release/reproducible-build/any(SOURCE_DATE_EPOCH).
Rust
- Toolchain:
rust-toolchain.toml; MSRV inCargo.toml. Task runner: Makefile wrapping cargo commands. - Format:
rustfmtwith a committedrustfmt.toml. - Lint:
cargo clippy --all-targets --all-features -- -D warnings. Configure in the[lints]table ofCargo.toml:unsafe_code = "forbid"(ordenywith documented exceptions); clippy groupsalldeny andpedanticwarn; plusunwrap_used,expect_used,panic,todo,dbg_macro,print_stdout,print_stderrset to deny in non-test code. Settoo_many_linesandcognitive_complexitythresholds inclippy.toml. - Errors:
thiserrorfor library error enums;anyhow/eyreonly in binaries, with.context(...).unwrap/expectonly for proven invariants, with an// INVARIANT:comment. - Design: newtypes for IDs/units; enums for state machines; traits as ports; workspace crates to enforce layering (domain crate has no IO deps). Every
unsafeblock has a// SAFETY:comment. - Tests:
cargo nextest;proptestfor logic/parsers;instafor reviewed snapshots;cargo fuzzfor untrusted input;mockallonly at adapter boundaries;mirifor anyunsafe. - Coverage:
cargo llvm-cov --lcov+diff-cover. - Logging:
tracing+tracing-subscriber;secrecy::SecretStringfor secrets. - Audit:
cargo deny check(advisories, licenses, bans, duplicates),cargo machete(unused deps),gitleaks. - Licenses: covered by
cargo deny([licenses]allowlist indeny.toml). - Slop guards: clippy
todo,dbg_macro,allow_attributes_without_reason(use#[expect(lint, reason = "…")]);jscpdfor duplication;cargo-mutantsfor mutation testing. - Benchmarks:
criterion(ordivan); save with--save-baseline main, compare with--baseline main. - API compatibility (libraries):
cargo semver-checks. - Reproducible builds:
cargo build --release --lockedwith--remap-path-prefix. - Checked by:
format/configured/rust,lint/configured/rust,lint/strict/rust(unwrap_used,expect_used,panic,todo,dbg_macro),repo/toolchain-pinned/rust,repo/lockfile-committed/rust,deps/locked-install/rust,deps/vulnerability-scan/rust,deps/unused-check/rust,deps/license-check/rust,quality/coverage-threshold/rust,release/reproducible-build/rust.types/strictdoes not apply.
Node.js / TypeScript
- Toolchain: pin Node via
.nvmrc/.node-versionand theenginesfield; one package manager, pinned withpackageManager(Corepack); commit the lockfile. TypeScript everywhere, ESM. - tsconfig:
strict,noUncheckedIndexedAccess,exactOptionalPropertyTypes,noImplicitOverride,noFallthroughCasesInSwitch,verbatimModuleSyntax. Runtsc --noEmitinlint.types/strict/noderequires the first five;fleetlint fix --applymerges them into tsconfig.json. - Format + lint: Prettier + ESLint with
typescript-eslintstrictTypeCheckedandstylisticTypeChecked— or Biome as an all-in-one alternative. Required rules:no-floating-promises,no-misused-promises,switch-exhaustiveness-check,no-explicit-any,no-console,max-lines(400/800),max-lines-per-function(50/80),complexity(15). Ratchet with ESLint bulk suppressions or a per-file baseline. - Errors: custom
Errorsubclasses withcause; nocatch {}; unknown errors narrowed before use; a top-levelunhandledRejection/uncaughtExceptionhandler that logs and exits. - Design:
zod(or valibot) to parse every boundary; branded types for IDs; discriminated unions for state;dependency-cruiser(oreslint-plugin-boundaries) for layer rules. - Tests: Vitest (or
node:test);fast-checkfor properties; MSW for HTTP; Testing Library for UI; Playwright for e2e; fake timers for clock. - Coverage: Vitest with
@vitest/coverage-v8(lcov/cobertura) +diff-cover. - Logging:
pinowithredactpaths for auth headers and tokens. - Audit:
npm audit --omit=dev(or the pnpm/yarn equivalent) /osv-scanner,knip(unused files, exports, deps),gitleaks. - Licenses:
license-checker-rseidelsohn --production --onlyAllow "<allowlist>". - Slop guards:
no-warning-comments(orunicorn/expiring-todo-comments),@eslint-community/eslint-comments/require-descriptionfor every disable comment, a focused-test ban (VitestallowOnly: false);jscpdfor duplication; Stryker for mutation testing. - Benchmarks and budgets:
vitest bench; bundle-size budgets withsize-limit; Lighthouse CI budgets for web apps. - API compatibility (libraries):
@microsoft/api-extractorwith a committed API report; any diff must be intentional. - UI:
@axe-core/playwrightin e2e tests (no violations allowed); PlaywrighttoHaveScreenshotfor visual regression;eslint-plugin-i18next(or the framework’s equivalent) bans hard-coded strings; a script fails on missing or unused translation keys. - Publishing:
npm publishfrom the tag-triggered workflow with trusted publishing (id-token: write, noNPM_TOKEN). - Checked by:
format/configured/node(Prettier, Biome or dprint),lint/configured/node(ESLint flat config, Biome or oxlint),types/strict/node,repo/toolchain-pinned/node,repo/lockfile-committed/node,deps/locked-install/node(npm cior the frozen-lockfile equivalent),deps/vulnerability-scan/node,deps/unused-check/node,deps/license-check/node,deps/install-scripts-disabled,quality/coverage-threshold/node. Not implemented yet for Node:lint/strict; reproducible builds fall back torelease/reproducible-build/any.
Kotlin (JVM / Android)
Detected by a Gradle build (build.gradle.kts, build.gradle) that applies Kotlin. A Gradle build without Kotlin is the Java profile; the Android shell of a Flutter app is neither.
- Toolchain: Gradle wrapper + version catalog (
libs.versions.toml); dependency locking; JVM toolchain pinned. Task runner: Gradle tasks (checkaggregates everything). - Format:
ktlint(orktfmt) via Spotless. - Lint:
detektwithbuildUponDefaultConfigand a baseline file for the ratchet. Enforce:EmptyCatchBlock,SwallowedException,TooGenericExceptionCaught,LongMethod(50),LargeClass,CognitiveComplexMethod(15),GlobalCoroutineUsage,InjectDispatcher,ForbiddenMethodCall(println). SetallWarningsAsErrors = true; explicit API mode for libraries. Android: Android Lint withwarningsAsErrorsand a baseline. - Errors/coroutines: sealed result/error hierarchies for expected failures; structured concurrency only (no
GlobalScope); never swallowCancellationException(rethrow it, or useensureActive()); inject dispatchers. - Design: sealed classes for state; value classes for IDs; constructor injection (Hilt/Koin/manual) wired in one place; module boundaries per layer, with
Konsistarchitecture tests. - Tests: JUnit 5 (or Kotest);
kotlinx-coroutines-test(runTest, test dispatchers); Turbine for Flows; MockK only at adapter boundaries; Robolectric / Compose UI tests on Android; Testcontainers on JVM. - Coverage: Kover (XML report) +
diff-cover. - Logging: SLF4J + Logback (JVM) or Timber (Android, debug tree only in debug builds).
- Secrets (Android): Android Keystore-backed encryption (e.g. via Tink) with DataStore; never plain SharedPreferences.
- Audit:
osv-scanneragainst the Gradle lockfiles, Gradle dependency analysis plugin (unused deps),gitleaks. - Licenses:
app.cash.licenseeGradle plugin with an allowlist. - Slop guards: detekt
ForbiddenComment(TODO/FIXME without an issue reference),UnusedPrivateMember,UnusedParameter; PMD CPD orjscpdfor duplication; Pitest (gradle-pitest-plugin) for mutation testing. - Benchmarks:
kotlinx-benchmark(JMH) on JVM; Jetpack Macrobenchmark for startup and scrolling on Android, plus Baseline Profiles. - API compatibility (libraries): binary-compatibility-validator (
apiDump/apiCheck) with the API file committed. - UI (Android): Compose UI tests with accessibility checks enabled; Roborazzi or Paparazzi screenshot tests; Android Lint
HardcodedTextand missing-translation checks as errors. - Checked by:
format/configured/kotlin,lint/configured/kotlin(the detekt Gradle plugin is applied),lint/strict/kotlin(SwallowedException, TooGenericExceptionCaught, EmptyCatchBlock, LongMethod, CognitiveComplexMethod),repo/toolchain-pinned/kotlin(a JDK pin is required),repo/lockfile-committed/kotlin,deps/locked-install/kotlin,deps/vulnerability-scan/kotlin,deps/unused-check/kotlin,deps/license-check/kotlin,quality/coverage-threshold/kotlin,release/reproducible-build/kotlin.types/strictdoes not apply.
Flutter / Dart
- Toolchain: pin the Flutter version (FVM or
.tool-versions); commitpubspec.lock. - Format:
dart format --set-exit-if-changed . - Lint:
flutter_lints(theanalysis_options.yamlfleetlint fix --applywrites includes it), or the strictervery_good_analysis;analyzer.language:strict-casts,strict-inferenceandstrict-raw-typesset to true (very_good_analysis sets them itself). Make sureuse_build_context_synchronously,unawaited_futures,discarded_futures,avoid_print,cancel_subscriptionsandclose_sinksare on. Runflutter analyze --fatal-infos. Ratchet with per-fileignore_for_filelists tracked in the repository. - Errors: sealed failure classes or a Result type;
FlutterError.onError+PlatformDispatcher.instance.onErroras the top-level handlers. - Design: one state approach (Riverpod or Bloc);
freezed+json_serializablefor models (no uncheckedascasts on JSON); repositories behind interfaces; nopart-file mixins sharing state. - Tests:
flutter_test,mocktail(prefer fakes),fake_async,bloc_test/ RiverpodProviderContainer, golden tests for key screens,integration_testfor e2e. - Coverage:
flutter test --coverage(lcov) +diff-cover. - Logging: the
loggingpackage with a redacting handler; debug output disabled in release. - Secrets:
flutter_secure_storage. Self-signed servers get a host-scopedSecurityContext, never a globalbadCertificateCallback. - Audit:
osv-scanneronpubspec.lock,dart pub outdated,gitleaks. - Licenses:
osv-scannerlicense scanning onpubspec.lockwith the allowlist; otherwise a script overdart pub deps --json. - Slop guards:
flutter_style_todosandavoid_print(on in the template),require_trailing_commas(very_good_analysis); every// ignore:needs a reason on the line above;jscpdfor duplication; themutation_testpackage for mutation testing. - Benchmarks:
benchmark_harnessfor pure Dart logic;integration_testwithtraceActionfor frame timings of key screens; app-size budget fromflutter build --analyze-size. - UI: widget tests with
meetsGuideline(textContrastGuideline),labeledTapTargetGuideline,androidTapTargetGuidelineandiOSTapTargetGuideline; golden tests in light/dark and large text;flutter gen-l10nwithuntranslated-messages-fileset, andcheckfails if that file is not empty. - Checked by:
format/configured/flutter(dart format),lint/configured/flutter,types/strict/flutter(the three strict modes),repo/toolchain-pinned/flutter,repo/lockfile-committed/flutter,deps/locked-install/flutter(pub get --enforce-lockfile),deps/unused-check/flutter(dependency_validator),quality/coverage-threshold/flutter. Vulnerability and license scans fall back to theanyimplementations (osv-scanner);lint/stricthas no Flutter implementation yet.
Java
Detected by pom.xml, or by a Gradle build (build.gradle, build.gradle.kts) that does not apply Kotlin; a Gradle build with Kotlin is the Kotlin profile.
- Toolchain:
.java-versionor.sdkmanrc(Temurin); the Maven wrapper (./mvnw) or the Gradle wrapper committed;maven-enforcer-pluginpins the Maven version. - Format: Spotless with google-java-format or Palantir;
spotless:checkin the hooks. - Lint: Checkstyle with a committed
config/checkstyle/checkstyle.xmlandfailOnViolation; Error Prone as a compiler plugin; SpotBugs for bug patterns.fleetlint fix --applywrites the Checkstyle configuration. - Errors: no
catch (Exception e)without rethrow (CheckstyleIllegalCatch,EmptyCatchBlock); checked exceptions translated at module boundaries. - Tests: JUnit 5, AssertJ, Testcontainers for integration; Mockito only at boundaries.
surefirefor unit tests,failsafefor integration. - Coverage: JaCoCo with
<rule>minimums injacoco-maven-plugin(checkgoal) plusdiff-coveron the XML report. - Audit: OWASP
dependency-check-mavenorosv-scanneron the dependency tree;gitleaks. - Licenses:
license-maven-plugin(third-party-reportwith an allowlist) orosv-scannerlicense scanning. - Slop guards: Checkstyle
TodoCommentrequiring an issue reference,SuppressWarningsforbidden without a reason filter; PMD CPD for duplication; Pitest for mutation testing. - API compatibility (libraries):
japicmp-maven-pluginor Revapi against the previous release. - Reproducible builds: Maven
project.build.outputTimestamp; GradlepreserveFileTimestamps = falseandreproducibleFileOrder = true(the default from Gradle 9). - Checked by:
format/configured/java,lint/configured/java(Checkstyle, Error Prone, SpotBugs or PMD in the build),lint/strict/java(no analyzer set to let findings pass),repo/toolchain-pinned/java(a JDK pin is required),repo/lockfile-committed/java,deps/locked-install/java,deps/vulnerability-scan/java,deps/unused-check/java,deps/license-check/java,quality/coverage-threshold/java,release/reproducible-build/java.types/strictdoes not apply.
.NET
Detected by global.json, Directory.Build.props, a .sln/.slnx or a .csproj/.fsproj.
- Toolchain:
global.jsonpins the SDK (rollForward: latestPatch);Directory.Packages.propsfor central package versions;dotnet restore --locked-modewithpackages.lock.jsoncommitted. - Format:
dotnet format --verify-no-changesin the hooks; style rules in.editorconfig. - Lint:
Directory.Build.propsat the root with<Nullable>enable,<TreatWarningsAsErrors>true,<AnalysisLevel>latest-all(orlatest-recommended) and<EnforceCodeStyleInBuild>true, so every project compiles under the same analyzers.fleetlint fix --applywrites the file. - Errors: no
catch (Exception)without rethrow (CA1031);Result-style types or exceptions, not both;ConfigureAwaitpolicy decided once. - Tests: xUnit, FluentAssertions or Shouldly, Testcontainers;
dotnet test --collect:"XPlat Code Coverage". - Coverage: coverlet with
/p:Thresholdordiff-coveron the Cobertura report. - Audit:
dotnet list package --vulnerable --include-transitivefailing on findings;gitleaks. - Licenses:
dotnet-project-licensesornuget-licensewith an allowlist. - Slop guards: analyzers IDE0005 (unused usings), CA1848/CA2254 (logging), a
TODOcheck via.editorconfigdotnet_diagnostic.S1135;jscpdfor duplication; Stryker.NET for mutation testing. - API compatibility (libraries):
Microsoft.DotNet.ApiCompat(EnablePackageValidationwith a baseline version). - Reproducible builds:
ContinuousIntegrationBuildtrue for CI builds; deterministic compilation is the SDK default. - Checked by:
format/configured/dotnet,lint/configured/dotnet,lint/strict/dotnet(Nullable, TreatWarningsAsErrors, AnalysisLevel),repo/toolchain-pinned/dotnet,repo/lockfile-committed/dotnet,deps/locked-install/dotnet(--locked-modeorRestoreLockedMode),deps/vulnerability-scan/dotnet,deps/license-check/dotnet,quality/coverage-threshold/dotnet,release/reproducible-build/dotnet.types/strictdoes not apply;deps/unused-checkhas no .NET implementation yet.
C/C++
Detected by CMakeLists.txt, meson.build, a Conan file or vcpkg.json.
- Toolchain: the compiler and standard pinned in presets (
CMakePresets.json), dependencies through Conan or vcpkg with a lockfile (conan.lock,vcpkg.jsonbuiltin-baseline). - Format:
clang-formatwith a committed.clang-format; the hook formats staged files. - Lint:
clang-tidywith a committed.clang-tidy(WarningsAsErrors: '*') overcompile_commands.json;-Wall -Wextra -Werror(CMAKE_COMPILE_WARNING_AS_ERROR).fleetlint fix --applywrites both files. - Errors: no swallowed exceptions (
bugprone-empty-catch),std::expected/error codes at boundaries, RAII everywhere (cppcoreguidelines-owning-memory). - Tests: Catch2 or GoogleTest through CTest; sanitizers (ASan, UBSan) in a dedicated preset run by
check. - Coverage:
gcovrorllvm-covwith--fail-under-line. - Audit:
osv-scanneron the lockfile;cppcheckas a second analyzer;gitleaks. - Licenses: Conan’s
conan graph info --format=jsonor vcpkg’s license fields against an allowlist. - Slop guards:
readability-function-cognitive-complexity,readability-function-size;jscpdor PMD CPD for duplication; Mull for mutation testing. - API compatibility (libraries):
abi-compliance-checkerorabidiffagainst the previous release. - Checked by:
format/configured/cpp,lint/configured/cpp(clang-tidy or cppcheck),lint/strict/cpp(WarningsAsErrors),repo/toolchain-pinned/cpp,repo/lockfile-committed/cpp,deps/vulnerability-scan/cpp,quality/coverage-threshold/cpp. License checks and reproducible builds fall back to theanyimplementations.types/strictdoes not apply;deps/locked-installanddeps/unused-checkhave no C/C++ implementation yet.
Ruby
Detected by Gemfile or a .gemspec.
- Toolchain:
.ruby-version; Bundler withGemfile.lockcommitted;bundle config set frozen truein CI. - Format and lint: RuboCop with a committed
.rubocop.yml(NewCops: enable, rubocop-performance, rubocop-rspec), or Standard;.rubocop_todo.ymlas the ratchet.fleetlint fix --applywrites.rubocop.yml. - Errors:
Lint/SuppressedExceptionon,Style/RescueStandardError: explicit; norescue Exception. - Tests: RSpec or Minitest;
webmock/vcrfor HTTP;simplecovwithminimum_coverage. - Coverage: SimpleCov
minimum_coverageanddiff-coveron the Cobertura formatter output. - Audit:
bundler-audit check --update;brakemanfor Rails;gitleaks. - Licenses:
license_finderwith an allowlist. - Slop guards:
Style/CommentAnnotationwith a required colon and an issue reference convention;flayorjscpdfor duplication;mutantfor mutation testing. - API compatibility (libraries): none standard; semantic versioning enforced by review and a changelog entry per public change.
- Checked by:
format/configured/ruby,lint/configured/ruby,lint/strict/ruby(NewCops: enable),repo/toolchain-pinned/ruby,repo/lockfile-committed/ruby,deps/locked-install/ruby(Bundler frozen),deps/vulnerability-scan/ruby,deps/license-check/ruby,quality/coverage-threshold/ruby. Reproducible builds fall back torelease/reproducible-build/any;types/strictanddeps/unused-checkhave no Ruby implementation yet.
PHP
Detected by composer.json.
- Toolchain:
.php-versionorcomposer.jsonconfig.platform.php;composer.lockcommitted;composer install --prefer-distin CI. - Format: PHP CS Fixer (
.php-cs-fixer.dist.php,@PER-CS,declare_strict_types) or Pint; the hook runs--dry-run. - Lint: PHPStan at
level: maxwithphpstan-strict-rules(phpstan.neon.dist) or Psalm; a generated baseline is the ratchet.fleetlint fix --applywrites both configurations. - Errors:
declare(strict_types=1)everywhere; exceptions typed per module; no emptycatch. - Tests: PHPUnit or Pest;
--fail-on-warning,--fail-on-risky. - Coverage: PHPUnit coverage (pcov) with
diff-coveron the Clover/Cobertura report. - Audit:
composer auditfailing on advisories;gitleaks. - Licenses:
composer licenses --format=jsonagainst an allowlist. - Slop guards: PHPStan’s
disallowedCallsforvar_dump/dd,ergebnis/phpstan-rulesfor TODO hygiene;jscpdorphpcpdfor duplication; Infection for mutation testing. - API compatibility (libraries):
roave/backward-compatibility-checkagainst the previous tag. - Checked by:
format/configured/php,lint/configured/php(PHPStan or Psalm),types/strict/php(PHPStanlevel: maxor PsalmerrorLevel="1"),repo/toolchain-pinned/php,repo/lockfile-committed/php,deps/locked-install/php(composer install, nocomposer updateoutside an update target),deps/vulnerability-scan/php,deps/unused-check/php,deps/license-check/php,quality/coverage-threshold/php. Reproducible builds fall back torelease/reproducible-build/any;lint/stricthas no PHP implementation yet.
Hugo / static sites
A documentation or marketing site is a repository like any other: it has a build that can break, links that can rot and a deployment that should be reproducible. fleetlint recognises a site by hugo.toml/hugo.yaml/hugo.json (also under config/_default/), or a legacy config.toml naming the baseURL next to a content/ directory.
- Toolchain: pin Hugo (
mise.toml,.tool-versions, or the version in the check workflow); the extended build when the site uses SCSS. The dev container uses thehugofeature; thedocker/podmanmodes useghcr.io/gohugoio/hugo. - Build (
lint):hugo --quiet --panicOnWarning --destination <tmp>: a missing layout, a brokenref/relrefor a deprecated setting fails the build instead of printing a warning. Checked bylint/configured/hugo. - Tests: a link and anchor check over the built site (every
hrefresolves, every#fragmentexists);markdownlinton the content. Hugo already fails on a link to a Markdown file that does not exist whenrefLinksErrorLevel = "ERROR". - Hooks: the build check scoped to content, layouts, assets, static and configuration;
markdownlint --fix. - CI:
peaceiris/actions-hugowith a pinnedHUGO_VERSION(Renovate bumps it), then the task runner’scheck. - Release: none; a site ships by deployment. The release rules stay not-applicable while no tag-triggered workflow exists.
- Slop guards:
markdownlintfor structure, the link check for dead references; no generatedpublic/orresources/_gentracked (.gitignore). - Checked by:
lint/configured/hugo,repo/toolchain-pinned/hugo. Formatting, type checking, lockfiles, dependency scans and coverage do not apply to a Hugo site (Hugo modules are checked as Go, npm tooling as Node);lint/stricthas no Hugo implementation.
Shared tools (all stacks)
| Purpose | Tool |
|---|---|
| Git hooks | prek (single binary, pre-commit compatible) |
| Shell scripts | shellcheck + shfmt |
| Editor/line-ending consistency | .editorconfig + .gitattributes |
| Changed-line coverage gate | diff-cover (reads lcov / Cobertura / JaCoCo) |
| Code metrics | scc or tokei |
| Secret scan | gitleaks (working tree + history) |
| Vulnerability scan | osv-scanner (any lockfile), plus the ecosystem tool above |
| Task runner | GNU Make (make check); Gradle or npm run where that’s the stack convention |
| Changelog from conventional commits | git-cliff |
| Signed tags | git tag -s (GPG or SSH signing key) |