@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/skills/shared/external/swiftlint/references/custom-rules-and-analyze.md

@@ -0,0 +1,170 @@
+# Custom Rules and Analyze
+
+Regex custom rules for project-specific enforcement, brief coverage of Swift custom rules, and the `swiftlint analyze` workflow.
+
+## Contents
+
+- [Regex Custom Rules](#regex-custom-rules)
+- [Swift Custom Rules](#swift-custom-rules)
+- [SwiftLint Analyze](#swiftlint-analyze)
+- [When to Use Analyzer Rules](#when-to-use-analyzer-rules)
+
+---
+
+## Regex Custom Rules
+
+Regex custom rules let you enforce project-specific patterns directly in `.swiftlint.yml` without building a custom SwiftLint binary.
+
+```yaml
+custom_rules:
+  no_print_statements:
+    name: "No print()"
+    regex: '^\s*print\s*\('
+    message: "Use os_log or Logger instead of print()"
+    severity: warning
+    match_kinds:
+      - identifier
+
+  no_hardcoded_colors:
+    name: "No hardcoded colors"
+    regex: 'UIColor\(\s*red:|\.init\(\s*red:'
+    message: "Use Color asset catalog entries instead of hardcoded RGB values"
+    severity: warning
+
+
+  todo_requires_ticket:
+    name: "TODO requires ticket"
+    regex: '//\s*TODO(?!.*\b[A-Z]+-\d+)'
+    message: "TODOs must reference a ticket (e.g., TODO: PROJ-123)"
+    severity: warning
+```
+
+### Custom rule configuration keys
+
+| Key | Required | Description |
+| --- | -------- | ----------- |
+| `name` | No | Human-readable name shown in violations |
+| `regex` | Yes | The pattern to match |
+| `capture_group` | No | Which regex capture group to highlight; defaults to `0` (the whole match) |
+| `message` | No | Custom violation message |
+| `severity` | No | `warning` (default) or `error` |
+| `match_kinds` | No | Limit matches to specific syntax kinds (e.g., `comment`, `identifier`, `string`) |
+| `excluded_match_kinds` | No | Exclude specific syntax kinds from matching; cannot be combined with `match_kinds` |
+| `included` | No | Regex pattern for file paths to include (note: regex, not glob) |
+| `excluded` | No | Regex pattern for file paths to exclude (note: regex, not glob) |
+| `execution_mode` | No | Per-rule execution mode: `default`, `swiftsyntax`, or `sourcekit` |
+
+### match_kinds values
+
+Syntax token kinds that SwiftLint recognizes: `argument`, `attribute.builtin`, `attribute.id`, `buildconfig.id`, `buildconfig.keyword`, `comment`, `comment.mark`, `comment.url`, `doccomment`, `doccomment.field`, `identifier`, `keyword`, `number`, `objectliteral`, `parameter`, `placeholder`, `string`, `string_interpolation_anchor`, `typeidentifier`.
+
+Use `match_kinds` to avoid false positives. For example, matching `print` only in `identifier` context avoids flagging it inside strings or comments.
+
+**Regex flags:** Custom rule regexes run with `s` (dot matches newlines) and `m` (`^`/`$` match line boundaries) enabled by default. Prepend `(?-s)` if you don't want `.` to match newlines.
+
+**`only_rules` interaction:** If using `only_rules` alongside `custom_rules`, you must include the literal string `custom_rules` in your `only_rules` list, or custom rules will not run.
+
+**Execution mode:** Individual custom rules can set `execution_mode` to `default`, `swiftsyntax`, or `sourcekit`. You can also set a top-level `default_execution_mode` to apply the same mode across all custom regex rules unless a rule overrides it.
+
+```yaml
+default_execution_mode: swiftsyntax
+
+custom_rules:
+  no_print_statements:
+    regex: '^\s*print\s*\('
+    execution_mode: sourcekit
+```
+
+## Swift Custom Rules
+
+SwiftLint supports rules written in Swift using the SwiftSyntax AST. These are more powerful than regex rules but require building SwiftLint from source with Bazel.
+
+This is an advanced workflow primarily useful for organizations that need precise AST-based enforcement. For most projects, regex custom rules are sufficient.
+
+If you need Swift custom rules:
+
+1. Clone [realm/SwiftLint](https://github.com/realm/SwiftLint)
+2. Scaffold a new rule with `swift run swiftlint-dev rules template <RuleName>` or add it under `Source/SwiftLintBuiltInRules/Rules/`
+3. Register the rule so it becomes part of the executable (`make register` in the SwiftLint repo workflow)
+4. Build the binary with Bazel: `bazel build :swiftlint`
+5. Use the resulting custom `swiftlint` binary in your project
+
+This is out of scope for typical project-level adoption.
+
+## SwiftLint Analyze
+
+`swiftlint analyze` runs analyzer rules that require the Swift compiler's type-checked AST. These rules can detect issues like unused imports and unused declarations that are impossible to catch with syntactic analysis alone.
+
+### Workflow
+
+1. Perform a **clean** build and capture the compiler log (incremental builds will fail):
+
+```sh
+# Xcode  -  clean build required
+xcodebuild -workspace MyApp.xcworkspace -scheme MyApp clean build \
+    | tee xcodebuild.log
+
+# SwiftPM  -  clean build required, -v needed for compiler command lines
+swift package clean
+swift build -v 2>&1 | tee swift-build.log
+```
+
+1. Run analyze with the compiler log:
+
+```sh
+swiftlint analyze --compiler-log-path xcodebuild.log
+```
+
+Or via the command plugin:
+
+```sh
+swift package plugin swiftlint -- analyze --compile-commands .build/debug.yaml
+```
+
+1. Configure which analyzer rules to enable:
+
+```yaml
+# .swiftlint.yml
+analyzer_rules:
+  - unused_import
+  - unused_declaration
+```
+
+### Autocorrect with analyze
+
+Analyzer rules that support autocorrect can fix issues:
+
+```sh
+swiftlint analyze --fix --compiler-log-path xcodebuild.log
+```
+
+`unused_import` is the most commonly used correctable analyzer rule  -  it removes unnecessary import statements.
+
+## When to Use Analyzer Rules
+
+Analyzer rules are slower than regular rules because they require a full build first. Use them when:
+
+- **Codebase hygiene matters**: `unused_import` catches import bloat that accumulates over refactoring.
+- **Dead code detection**: `unused_declaration` finds private declarations that are never referenced.
+- **CI only**: Run analyzer rules in CI rather than on every local build to avoid slowing down the development loop.
+
+A practical pattern is to run analyzer rules in a separate CI job that runs less frequently (e.g., nightly or on main branch only):
+
+```yaml
+# GitHub Actions  -  nightly analyze
+on:
+  schedule:
+    - cron: '0 6 * * *'
+
+jobs:
+  analyze:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build
+        run: swift build -v 2>&1 | tee swift-build.log
+      - name: Analyze
+        run: |
+          brew install swiftlint
+          swiftlint analyze --strict --compiler-log-path swift-build.log
+```

package/pipeline/skills/shared/external/swiftlint/references/plugins-run-scripts-and-integrations.md

@@ -0,0 +1,307 @@
+# Plugins, Run Scripts, and Integrations
+
+Setup instructions for each SwiftLint integration method: build tool plugin, command plugin, Xcode run scripts, CI, and secondary integrations.
+
+## Contents
+
+- [Build Tool Plugin (Recommended)](#build-tool-plugin-recommended)
+- [Command Plugin](#command-plugin)
+- [Xcode Run Script Build Phase](#xcode-run-script-build-phase)
+- [CI Recipes](#ci-recipes)
+- [Working With Multiple Swift Versions](#working-with-multiple-swift-versions)
+- [VS Code](#vs-code)
+- [Fastlane](#fastlane)
+- [Docker](#docker)
+- [Pre-commit Hook](#pre-commit-hook)
+
+---
+
+## Build Tool Plugin (Recommended)
+
+The `SwiftLintBuildToolPlugin` from [SimplyDanny/SwiftLintPlugins](https://github.com/SimplyDanny/SwiftLintPlugins) runs SwiftLint as part of the build. No Homebrew or PATH setup needed.
+
+### SwiftPM setup
+
+```swift
+// Package.swift
+let package = Package(
+    name: "MyApp",
+    dependencies: [
+    .package(url: "https://github.com/SimplyDanny/SwiftLintPlugins", from: "<reviewed-version>")
+    ],
+    targets: [
+        .target(
+            name: "MyApp",
+            plugins: [.plugin(name: "SwiftLintBuildToolPlugin", package: "SwiftLintPlugins")]
+        ),
+        .testTarget(
+            name: "MyAppTests",
+            dependencies: ["MyApp"],
+            plugins: [.plugin(name: "SwiftLintBuildToolPlugin", package: "SwiftLintPlugins")]
+        )
+    ]
+)
+```
+
+### Xcode project setup (no Package.swift)
+
+1. **File > Add Package Dependencies** → add `https://github.com/SimplyDanny/SwiftLintPlugins`
+2. For each target you want to lint, go to **Build Phases** and add `SwiftLintBuildToolPlugin` under **Run Build Tool Plug-ins**
+3. When prompted, trust the plugin
+
+### Plugin trust
+
+On first build, Xcode shows a trust dialog. Select **Trust & Enable All** for the SwiftLintPlugins package. In CI with `xcodebuild`, pass:
+
+```sh
+xcodebuild -skipPackagePluginValidation -skipMacroValidation ...
+```
+
+### Limitations
+
+- The build tool plugin cannot run `--fix` (it has read-only access to sources).
+- It cannot pass `--baseline` or other CLI flags  -  build tool plugins do not accept arguments. Use config keys like `baseline:` / `write_baseline:` where available, or switch to the command plugin / direct CLI for advanced flag-based workflows.
+- It runs on every build, which is desirable for local development but may slow clean builds in large projects.
+
+## Command Plugin
+
+The command plugin provides broad SwiftPM-based CLI access to SwiftLint, including `--fix`, `--baseline`, and `analyze` workflows that the build tool plugin cannot handle directly:
+
+```sh
+swift package plugin swiftlint
+swift package plugin swiftlint --fix
+swift package plugin swiftlint -- --strict --baseline .swiftlint.baseline
+swift package plugin swiftlint -- analyze --compile-commands .build/debug.yaml
+```
+
+The command plugin requires the same `SwiftLintPlugins` dependency. It has read-write access to sources (for `--fix`) and accepts all CLI flags after `--`.
+
+## Xcode Run Script Build Phase
+
+Use a run script when the build tool plugin is impractical for your project shape or when you need CLI features the build tool plugin cannot provide (for example `--fix` locally or `--baseline`). Xcode projects can still use the build tool plugin via Xcode Package Dependency even without a local `Package.swift`.
+
+### Basic run script
+
+1. Select the target → **Build Phases** → **+** → **New Run Script Phase**
+2. Move the phase **after Compile Sources**  -  SwiftLint is designed to analyze valid, compilable source code; linting before compilation leads to confusing results
+3. Add the script:
+
+```sh
+if command -v swiftlint >/dev/null 2>&1; then
+    swiftlint
+else
+    echo "warning: SwiftLint not installed. Install with: brew install swiftlint"
+fi
+```
+
+On Apple Silicon with Homebrew, `swiftlint` is often installed at `/opt/homebrew/bin/swiftlint`. If the run script cannot find it, either export that path in the build phase or create a symlink into `/usr/local/bin`:
+
+```sh
+if [[ "$(uname -m)" == arm64 ]]; then
+  export PATH="/opt/homebrew/bin:$PATH"
+fi
+
+if command -v swiftlint >/dev/null 2>&1; then
+  swiftlint
+else
+  echo "warning: SwiftLint not installed. Install with: brew install swiftlint"
+fi
+```
+
+### Run script with script input files (Xcode 15+)
+
+Xcode 15 sandboxes run scripts by default. If SwiftLint fails with `Sandbox: swiftlint ... deny(1) file-read-data`, set `ENABLE_USER_SCRIPT_SANDBOXING = NO` for the target. Input files and input file lists are a separate optimization for limiting which files are linted.
+
+1. Set `ENABLE_USER_SCRIPT_SANDBOXING = NO` for the target if the script cannot read source files under Xcode 15+
+2. Under the run script phase, check **Based on dependency analysis**
+3. Add either explicit **Input Files** or readable `.xcfilelist` paths under **Input File Lists**
+4. Use `--use-script-input-file-lists` when Xcode is providing `.xcfilelist` paths:
+
+```sh
+if command -v swiftlint >/dev/null 2>&1; then
+  swiftlint --use-script-input-file-lists
+fi
+```
+
+This requires Xcode to populate `SCRIPT_INPUT_FILE_LIST_COUNT` and `SCRIPT_INPUT_FILE_LIST_n` with readable `.xcfilelist` paths. Use `--use-script-input-files` only when Xcode is populating `SCRIPT_INPUT_FILE_COUNT` and `SCRIPT_INPUT_FILE_n` directly via **Input Files** rather than **Input File Lists**.
+
+Alternatively, to lint the full target without file lists:
+
+```sh
+if command -v swiftlint >/dev/null 2>&1; then
+    swiftlint lint --config "${SRCROOT}/.swiftlint.yml"
+fi
+```
+
+And uncheck **Based on dependency analysis** if you want it to run every build.
+
+### CocoaPods run script
+
+```sh
+"${PODS_ROOT}/SwiftLint/swiftlint"
+```
+
+## CI Recipes
+
+### GitHub Actions
+
+```yaml
+name: SwiftLint
+on:
+  pull_request:
+    paths: ['**/*.swift']
+
+jobs:
+  lint:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install SwiftLint
+        run: brew install swiftlint
+      - name: Lint
+        run: swiftlint --strict --reporter github-actions-logging
+```
+
+For SARIF upload to GitHub code scanning:
+
+```yaml
+      - name: Lint (SARIF)
+        run: swiftlint --strict --reporter sarif > swiftlint.sarif
+        continue-on-error: true
+      - name: Upload SARIF
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: swiftlint.sarif
+```
+
+### GitHub Actions with baseline
+
+```yaml
+      - name: Lint (baseline)
+        run: swiftlint --strict --baseline .swiftlint.baseline --reporter github-actions-logging
+```
+
+### GitLab CI
+
+```yaml
+swiftlint:
+  image: ghcr.io/realm/swiftlint:latest
+  script:
+    - swiftlint --strict --reporter codeclimate > swiftlint.json
+  artifacts:
+    reports:
+      codequality: swiftlint.json
+```
+
+If you want GitLab JUnit-style output instead, use `--reporter gitlab` and publish the result as a JUnit artifact rather than `codequality`.
+
+### Bitrise / other CI
+
+```sh
+brew install swiftlint
+swiftlint --strict
+```
+
+### Reporter summary
+
+| Reporter | Format | Best for |
+| -------- | ------ | -------- |
+| `xcode` | Xcode-compatible text | Local builds, Xcode run scripts |
+| `github-actions-logging` | GitHub Actions annotations | PR inline comments |
+| `sarif` | SARIF JSON | GitHub code scanning |
+| `json` | JSON array | Custom tooling, dashboards |
+| `checkstyle` | XML | Jenkins, SonarQube |
+| `csv` | CSV | Spreadsheet analysis |
+| `emoji` | Text with emoji | Fun terminal output |
+
+## Working With Multiple Swift Versions
+
+SwiftLint is predominantly SwiftSyntax-based, but some rules still rely on SourceKit/Clang for additional analysis. It must remain compatible with the Swift toolchain used to compile your project.
+
+**Key rules:**
+
+1. Run SwiftLint with the same Swift toolchain used to build your project.
+2. On macOS, SwiftLint resolves the toolchain in this order: `XCODE_DEFAULT_TOOLCHAIN_OVERRIDE`, `TOOLCHAIN_DIR` or `TOOLCHAINS`, `xcrun -find swift`, `/Applications/Xcode.app/...`, `/Applications/Xcode-beta.app/...`, `~/Applications/Xcode.app/...`, `~/Applications/Xcode-beta.app/...`.
+3. In CI with multiple Xcode versions, set `DEVELOPER_DIR` before running SwiftLint:
+
+```sh
+export DEVELOPER_DIR=/Applications/Xcode_16.app/Contents/Developer
+swiftlint
+```
+
+1. The build tool plugin automatically uses the correct toolchain because it runs within the build system.
+2. Homebrew-installed SwiftLint may lag behind the latest Swift release. If you see parsing errors after updating Xcode, check for a SwiftLint update.
+3. `sourcekitd.framework` is expected in the selected toolchain's `usr/lib/` directory. Toolchain mismatches typically show up as parsing or SourceKit failures.
+
+## VS Code
+
+The [SwiftLint VS Code extension](https://marketplace.visualstudio.com/items?itemName=vknabel.vscode-swiftlint) runs SwiftLint on save.
+
+```json
+// .vscode/settings.json
+{
+    "swiftlint.enable": true,
+    "swiftlint.path": "/opt/homebrew/bin/swiftlint",
+    "swiftlint.autoLintWorkspace": false
+}
+```
+
+## Fastlane
+
+```ruby
+# Fastfile
+lane :lint do
+  swiftlint(
+    mode: :lint,
+    config_file: ".swiftlint.yml",
+    strict: true,
+    raise_if_swiftlint_error: true
+  )
+end
+```
+
+## Docker
+
+The official SwiftLint Docker image is useful for Linux CI:
+
+```sh
+docker run --rm -v "$(pwd):/work" -w /work ghcr.io/realm/swiftlint:<reviewed-version> --strict
+```
+
+## Pre-commit Hook
+
+### Using the pre-commit framework
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  - repo: https://github.com/realm/SwiftLint
+    rev: <reviewed-version>
+    hooks:
+      - id: swiftlint
+```
+
+To apply fixes and fail on warnings/errors from the hook, use an `entry` override:
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  - repo: https://github.com/realm/SwiftLint
+    rev: <reviewed-version>
+    hooks:
+      - id: swiftlint
+        entry: swiftlint --fix --strict
+```
+
+### Manual git hook
+
+```sh
+#!/bin/sh
+# .git/hooks/pre-commit
+if command -v swiftlint >/dev/null 2>&1; then
+    git diff --cached --name-only --diff-filter=d -- '*.swift' | \
+        xargs -I{} swiftlint lint --path "{}" --strict --quiet
+fi
+```
+
+Make it executable: `chmod +x .git/hooks/pre-commit`

package/pipeline/skills/shared/external/swiftlint/references/rule-reference.md

@@ -0,0 +1,35 @@
+# Bundled Rule Index
+
+This file is an exhaustive local index of SwiftLint rule identifiers grouped by the official rule-directory categories. Use it to avoid leaving a rule out when working offline or scanning the repo quickly.
+
+Treat the official rule directory and `swiftlint rules <identifier>` as the source of truth for current descriptions, configuration keys, autocorrect support, and future rule additions or reclassifications.
+
+## Contents
+
+- [Default Rules](#default-rules)
+- [Opt-in Rules](#opt-in-rules)
+- [Analyzer Rules](#analyzer-rules)
+
+---
+
+## Default Rules
+
+These rules are enabled automatically. Disable specific ones via `disabled_rules` in `.swiftlint.yml`.
+
+`attribute_name_spacing`, `blanket_disable_command`, `block_based_kvo`, `class_delegate_protocol`, `closing_brace`, `closure_parameter_position`, `colon`, `comma`, `comment_spacing`, `compiler_protocol_init`, `computed_accessors_order`, `control_statement`, `custom_rules`, `cyclomatic_complexity`, `deployment_target`, `discouraged_direct_init`, `duplicate_conditions`, `duplicate_enum_cases`, `duplicate_imports`, `duplicated_key_in_dictionary_literal`, `dynamic_inline`, `empty_enum_arguments`, `empty_parameters`, `empty_parentheses_with_trailing_closure`, `file_length`, `for_where`, `force_cast`, `force_try`, `function_body_length`, `function_name_whitespace`, `function_parameter_count`, `generic_type_name`, `identifier_name`, `implicit_getter`, `implicit_optional_initialization`, `inclusive_language`, `invalid_swiftlint_command`, `invisible_character`, `is_disjoint`, `large_tuple`, `leading_whitespace`, `legacy_cggeometry_functions`, `legacy_constant`, `legacy_constructor`, `legacy_hashing`, `legacy_nsgeometry_functions`, `legacy_random`, `line_length`, `mark`, `multiple_closures_with_trailing_closure`, `nesting`, `no_fallthrough_only`, `no_space_in_method_call`, `non_optional_string_data_conversion`, `notification_center_detachment`, `ns_number_init_as_function_reference`, `nsobject_prefer_isequal`, `opening_brace`, `optional_data_string_conversion`, `orphaned_doc_comment`, `prefer_type_checking`, `private_over_fileprivate`, `private_unit_test`, `protocol_property_accessors_order`, `reduce_boolean`, `redundant_discardable_let`, `redundant_objc_attribute`, `redundant_sendable`, `redundant_set_access_control`, `redundant_string_enum_value`, `redundant_void_return`, `return_arrow_whitespace`, `self_in_property_initialization`, `shorthand_operator`, `statement_position`, `static_over_final_class`, `superfluous_disable_command`, `switch_case_alignment`, `syntactic_sugar`, `todo`, `trailing_comma`, `trailing_newline`, `trailing_semicolon`, `trailing_whitespace`, `type_body_length`, `type_name`, `unavailable_condition`, `unneeded_break_in_switch`, `unneeded_override`, `unneeded_synthesized_initializer`, `unused_closure_parameter`, `unused_control_flow_label`, `unused_enumerated`, `unused_optional_binding`, `unused_setter_value`, `valid_ibinspectable`, `vertical_parameter_alignment`, `vertical_whitespace`, `void_function_in_ternary`, `void_return`, `xctfail_message`
+
+---
+
+## Opt-in Rules
+
+These rules are disabled by default. Enable selectively via `opt_in_rules` in `.swiftlint.yml`.
+
+`accessibility_label_for_image`, `accessibility_trait_for_button`, `anonymous_argument_in_multiline_closure`, `array_init`, `async_without_await`, `attributes`, `balanced_xctest_lifecycle`, `closure_body_length`, `closure_end_indentation`, `closure_spacing`, `collection_alignment`, `comma_inheritance`, `conditional_returns_on_newline`, `contains_over_filter_count`, `contains_over_filter_is_empty`, `contains_over_first_not_nil`, `contains_over_range_nil_comparison`, `contrasted_opening_brace`, `convenience_type`, `direct_return`, `discarded_notification_center_observer`, `discouraged_assert`, `discouraged_default_parameter`, `discouraged_none_name`, `discouraged_object_literal`, `discouraged_optional_boolean`, `discouraged_optional_collection`, `empty_collection_literal`, `empty_count`, `empty_string`, `empty_xctest_method`, `enum_case_associated_values_count`, `expiring_todo`, `explicit_acl`, `explicit_enum_raw_value`, `explicit_init`, `explicit_top_level_acl`, `explicit_type_interface`, `extension_access_modifier`, `fallthrough`, `fatal_error_message`, `file_header`, `file_name`, `file_name_no_space`, `file_types_order`, `final_test_case`, `first_where`, `flatmap_over_map_reduce`, `force_unwrapping`, `function_default_parameter_at_end`, `ibinspectable_in_extension`, `identical_operands`, `implicit_return`, `implicitly_unwrapped_optional`, `incompatible_concurrency_annotation`, `indentation_width`, `joined_default_parameter`, `last_where`, `legacy_multiple`, `legacy_objc_type`, `legacy_uigraphics_function`, `let_var_whitespace`, `literal_expression_end_indentation`, `local_doc_comment`, `lower_acl_than_parent`, `missing_docs`, `modifier_order`, `multiline_arguments`, `multiline_arguments_brackets`, `multiline_call_arguments`, `multiline_function_chains`, `multiline_literal_brackets`, `multiline_parameters`, `multiline_parameters_brackets`, `nimble_operator`, `no_empty_block`, `no_extension_access_modifier`, `no_grouping_extension`, `no_magic_numbers`, `non_overridable_class_declaration`, `nslocalizedstring_key`, `nslocalizedstring_require_bundle`, `number_separator`, `object_literal`, `one_declaration_per_file`, `operator_usage_whitespace`, `optional_enum_case_matching`, `overridden_super_call`, `override_in_extension`, `pattern_matching_keywords`, `period_spacing`, `prefer_asset_symbols`, `prefer_condition_list`, `prefer_key_path`, `prefer_nimble`, `prefer_self_in_static_references`, `prefer_self_type_over_type_of_self`, `prefer_zero_over_explicit_init`, `prefixed_toplevel_constant`, `private_action`, `private_outlet`, `private_subject`, `private_swiftui_state`, `prohibited_interface_builder`, `prohibited_super_call`, `quick_discouraged_call`, `quick_discouraged_focused_test`, `quick_discouraged_pending_test`, `raw_value_for_camel_cased_codable_enum`, `reduce_into`, `redundant_final`, `redundant_nil_coalescing`, `redundant_self`, `redundant_type_annotation`, `required_deinit`, `required_enum_case`, `return_value_from_void_function`, `self_binding`, `shorthand_argument`, `shorthand_optional_binding`, `single_test_class`, `sorted_enum_cases`, `sorted_first_last`, `sorted_imports`, `static_operator`, `strict_fileprivate`, `strong_iboutlet`, `superfluous_else`, `switch_case_on_newline`, `test_case_accessibility`, `toggle_bool`, `trailing_closure`, `type_contents_order`, `unavailable_function`, `unhandled_throwing_task`, `unneeded_escaping`, `unneeded_parentheses_in_closure_argument`, `unneeded_throws_rethrows`, `unowned_variable_capture`, `untyped_error_in_catch`, `unused_parameter`, `variable_shadowing`, `vertical_parameter_alignment_on_call`, `vertical_whitespace_between_cases`, `vertical_whitespace_closing_braces`, `vertical_whitespace_opening_braces`, `weak_delegate`, `xct_specific_matcher`, `yoda_condition`
+
+---
+
+## Analyzer Rules
+
+These rules require the Swift compiler's type-checked AST. Run via `swiftlint analyze --compiler-log-path <log>`. See the custom rules and analyze reference for the full workflow.
+
+`capture_variable`, `explicit_self`, `typesafe_array_init`, `unused_declaration`, `unused_import`