@herbertgao/pi-extensions 2026.8.13 → 2026.8.15

package/node_modules/pi-lens/rules/ast-grep-rules/rules/go-prefer-string-builder.yml

@@ -0,0 +1,43 @@
+# Go Prefer strings.Builder Over Repeated Concatenation
+# Detects repeated string concatenation (x = x + y / x += "y") that should use
+# strings.Builder instead. The += arm requires a string literal because
+# ast-grep has no type information to distinguish string and numeric operands.
+# Ported from vinhnx/VTCode rules/go/prefer-string-builder.yml
+# (#2200, refs #2195).
+id: go-prefer-string-builder
+language: go
+severity: hint
+message: "Use strings.Builder instead of repeated string concatenation"
+note: |
+  Repeated string concatenation with + creates a new string allocation on
+  each operation (O(n^2) total). strings.Builder accumulates bytes in a
+  buffer and produces the final string with one allocation.
+  Detection-only, with no autofix: a single concatenation site cannot show
+  this is a genuine accumulation loop rather than a one-off assignment where
+  concatenation is clearer, and no fix can safely introduce the surrounding
+  strings.Builder declaration and .String() call. Scoped to non-test Go
+  files.
+rule:
+  any:
+    - pattern: $VAR = $VAR + $OTHER
+    - pattern: $VAR += "$OTHER"
+ignores:
+  - "**/*_test.go"
+tags:
+  - go
+  - idiom
+  - performance
+examples:
+  bad: |
+    func concat(a string, b string) string {
+        a = a + b
+        return a
+    }
+  good: |
+    func build(parts []string) string {
+        var b strings.Builder
+        for _, p := range parts {
+            b.WriteString(p)
+        }
+        return b.String()
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rules/hyphenated-svg-attribute.yml

@@ -0,0 +1,32 @@
+id: hyphenated-svg-attribute
+language: Tsx
+severity: warning
+message: "Use camelCase for this known SVG attribute in JSX"
+note: |
+  React JSX uses camelCase for SVG attributes. The rule is limited to the
+  known SVG attribute names below, so custom elements and web components with
+  legitimate hyphenated properties are not reported.
+rule:
+  kind: jsx_attribute
+  has:
+    kind: property_identifier
+    regex: "^(stroke-width|stroke-linecap|stroke-linejoin|stroke-miterlimit|stroke-dasharray|stroke-dashoffset|fill-rule|clip-rule|clip-path|font-family|font-size|font-weight|text-anchor|dominant-baseline|stop-color|stop-opacity|fill-opacity|stroke-opacity|color-interpolation-filters|shape-rendering|vector-effect|flood-color|flood-opacity|lighting-color|marker-height|marker-width|xlink-href|mask-type)$"
+  inside:
+    any:
+      - kind: jsx_self_closing_element
+        has:
+          field: name
+          regex: '^(svg|path|circle|rect|line|polyline|polygon|ellipse|g|defs|use|symbol|clipPath|mask|pattern|marker|linearGradient|radialGradient|stop|text|tspan|foreignObject)$'
+      - kind: jsx_opening_element
+        has:
+          field: name
+          regex: '^(svg|path|circle|rect|line|polyline|polygon|ellipse|g|defs|use|symbol|clipPath|mask|pattern|marker|linearGradient|radialGradient|stop|text|tspan|foreignObject)$'
+has_fix: false
+tags:
+  - tsx
+  - jsx
+  - svg
+  - modernization
+examples:
+  bad: "const icon = <svg stroke-width=\"2\" />;"
+  good: "const icon = <svg strokeWidth=\"2\" />;"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-lateinit.yml

@@ -0,0 +1,37 @@
+# Kotlin No lateinit
+# Detects `lateinit var` property declarations.
+# Ported from vinhnx/VTCode rules/kotlin/no-lateinit.yml (#2198, refs #2195).
+id: kotlin-no-lateinit
+language: kotlin
+severity: warning
+message: "Avoid lateinit var; prefer a nullable type or constructor injection"
+note: |
+  lateinit defers initialization past the constructor and throws
+  UninitializedPropertyAccessException on an unguarded read before the
+  property is set. A nullable type, a lazy delegate, or constructor/DI-based
+  initialization all make the missing-value case visible to the type system
+  instead of a runtime crash.
+  Detection-only: the correct replacement depends on the property's
+  lifecycle (Android view binding, DI-managed fields, test fixtures) and on
+  whether callers can tolerate a nullable read, both of which this rule
+  cannot verify.
+rule:
+  kind: property_declaration
+  has:
+    kind: modifiers
+    has:
+      kind: member_modifier
+      regex: "^lateinit$"
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - null-safety
+examples:
+  bad: |
+    class UserRepository {
+        lateinit var apiClient: ApiClient
+    }
+  good: |
+    class UserRepository(private val apiClient: ApiClient)

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-nullable-boolean.yml

@@ -0,0 +1,33 @@
+# Kotlin No nullable Boolean
+# Detects a `Boolean?` type on a property, parameter, or return type.
+# Ported from vinhnx/VTCode rules/kotlin/no-nullable-boolean.yml (#2198, refs #2195).
+id: kotlin-no-nullable-boolean
+language: kotlin
+severity: warning
+message: "Avoid a nullable Boolean; a two-value enum or a non-null default is usually clearer"
+note: |
+  A nullable Boolean gives a value three states (true/false/unknown) but the
+  type only documents two, so callers routinely forget to handle null and
+  either crash on an unboxing NPE or silently treat it as false.
+  Detection-only: null is a legitimate third state for some APIs (an
+  unanswered tri-state form field, a "not yet loaded" flag), and this rule
+  cannot tell that case from an accidental nullable Boolean.
+rule:
+  kind: nullable_type
+  has:
+    kind: user_type
+    has:
+      kind: type_identifier
+      regex: "^Boolean$"
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - null-safety
+examples:
+  bad: |
+    fun isEligible(): Boolean? = null
+  good: |
+    enum class Eligibility { ELIGIBLE, INELIGIBLE, UNKNOWN }
+    fun eligibility(): Eligibility = Eligibility.UNKNOWN

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-println.yml

@@ -0,0 +1,42 @@
+# Kotlin No println
+# Detects bare `println`/`print` calls.
+# Ported from vinhnx/VTCode rules/kotlin/no-println.yml (#2198, refs #2195).
+id: kotlin-no-println
+language: kotlin
+severity: warning
+message: "Avoid println/print; use a structured logger"
+note: |
+  Direct console output via println/print is not configurable and cannot be
+  routed to log aggregators or filtered by level. Use a structured logging
+  library (kotlin-logging, SLF4J, android.util.Log) for production code.
+  Detection-only: which logger to use, and whether a given call site is a
+  CLI entry point or a test where println is acceptable, is a project
+  policy call this rule cannot make.
+  Scoped to the unqualified call. A fully-qualified spelling
+  (`kotlin.io.println(...)`) is missed on purpose: syntactically it is the
+  same navigation-call shape as `anyReceiver.println(...)`, a member call on
+  an arbitrary type (a Writer, a PrintStream) that this rule must not flag,
+  and there is no type information here to tell the two apart.
+rule:
+  any:
+    - pattern: println($$$ARGS)
+    - pattern: print($$$ARGS)
+files:
+  - "**/*.kt"
+ignores:
+  - "**/*Test.kt"
+  - "**/test/**"
+tags:
+  - kotlin
+  - idiom
+  - logging
+examples:
+  bad: |
+    fun main() {
+        println("starting up")
+    }
+  good: |
+    private val logger = KotlinLogging.logger {}
+    fun main() {
+        logger.info { "starting up" }
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-unnecessary-let.yml

@@ -0,0 +1,28 @@
+# Kotlin No unnecessary let
+# Detects `.let { }` called on a receiver without a preceding safe-call `?.`.
+# Ported from vinhnx/VTCode rules/kotlin/no-unnecessary-let.yml (#2198, refs #2195).
+id: kotlin-no-unnecessary-let
+language: kotlin
+severity: warning
+message: "let on a non-null-checked receiver adds indirection; use the value directly"
+note: |
+  `.let { }` exists to scope a null-safe transform after `?.`. Calling it on
+  a receiver that is already known non-null (no `?.`) just renames the
+  receiver to `it` inside a lambda, adding a level of nesting with no
+  null-safety benefit.
+  Detection-only: the receiver's own nullability is not tracked here, and
+  `.let` also has legitimate uses for scoping a mutable local or chaining a
+  builder, which this pattern cannot distinguish from the redundant case.
+rule:
+  pattern: $RECEIVER.let { $$$BODY }
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - readability
+examples:
+  bad: |
+    val length = name.let { it.length }
+  good: |
+    val length = name.length

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-unsafe-cast.yml

@@ -0,0 +1,28 @@
+# Kotlin No unsafe cast
+# Detects the unsafe `as` cast (as opposed to the safe `as?` cast).
+# Ported from vinhnx/VTCode rules/kotlin/no-unsafe-cast.yml (#2198, refs #2195).
+id: kotlin-no-unsafe-cast
+language: kotlin
+severity: warning
+message: "Unsafe cast (as) throws ClassCastException on a mismatch; consider as?"
+note: |
+  `as` throws ClassCastException immediately when the value isn't the target
+  type. `as?` returns null instead, which is usually safer when the caller
+  can handle a missing value.
+  Detection-only: `as?` changes a thrown failure into a silent null, which
+  is a real behavior change a caller must handle explicitly. Whether the
+  unsafe throw is actually the intended contract (a precondition the caller
+  already established) is a call this rule cannot make.
+rule:
+  pattern: $VALUE as $TYPE
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - null-safety
+examples:
+  bad: |
+    val name = value as String
+  good: |
+    val name = value as? String ?: return

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-no-var.yml

@@ -0,0 +1,35 @@
+# Kotlin No var
+# Detects a `var` property or local declaration (as opposed to `val`).
+# Ported from vinhnx/VTCode rules/kotlin/no-var.yml (#2198, refs #2195).
+id: kotlin-no-var
+language: kotlin
+severity: warning
+message: "Prefer val over var; mutability should be explicit and scoped"
+note: |
+  Kotlin favors immutability by default. A `var` where a `val` would do
+  widens the set of places a value can change, which makes reasoning about
+  the surrounding code harder as it grows.
+  Detection-only: some `var`s are load-bearing (loop counters, accumulators,
+  lifecycle-managed fields), and rewriting to `val` requires knowing every
+  call site's mutation intent, which this rule cannot verify.
+  A `lateinit var` also matches `kotlin-no-lateinit`, so it reports twice.
+  That's intentional, not a bug to dedupe: the two findings name different
+  problems (mutability here, deferred-initialization risk there) and either
+  one could be fixed independently of the other.
+rule:
+  kind: property_declaration
+  has:
+    kind: binding_pattern_kind
+    regex: "^var$"
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - immutability
+examples:
+  bad: |
+    var total = 0
+    total = total + price
+  good: |
+    val total = prices.sum()

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-prefer-data-class.yml

@@ -0,0 +1,66 @@
+# Kotlin Prefer data class
+# Detects a plain class whose primary constructor is made entirely of
+# val/var properties and that carries no additional behavior (a function, an
+# init block, or a computed property), a strong signal it's a value holder
+# that should be a data class.
+# Ported from vinhnx/VTCode rules/kotlin/prefer-data-class.yml (#2198, refs #2195).
+id: kotlin-prefer-data-class
+language: kotlin
+severity: warning
+message: "This class looks like a plain value holder; consider a data class"
+note: |
+  A data class generates equals/hashCode/toString/copy/componentN for free,
+  which a hand-written value holder either lacks or must maintain by hand.
+  Detection-only: adding `data` changes equality semantics (structural
+  instead of referential) and generates a public API surface (copy,
+  componentN) the class may not want to expose, neither of which this rule
+  can verify — it excludes classes carrying any modifier
+  (open/abstract/sealed/inner/data/enum/…) and classes with a function, an
+  init block, or a computed property in their body, but a caller may still
+  have other reasons the plain class is intentional.
+  A class that extends another type through its primary constructor (a
+  delegation specifier, e.g. `class Ok(val v: String) : Result()`) still
+  matches: since Kotlin 1.1, a data class may extend another class, so
+  inheritance alone is not a reason to exclude it.
+rule:
+  all:
+    - kind: class_declaration
+    - not:
+        has:
+          kind: modifiers
+    - has:
+        kind: primary_constructor
+        has:
+          kind: class_parameter
+        not:
+          has:
+            kind: class_parameter
+            not:
+              has:
+                kind: binding_pattern_kind
+    - not:
+        has:
+          kind: class_body
+          any:
+            - has:
+                kind: function_declaration
+            - has:
+                kind: anonymous_initializer
+            - has:
+                kind: property_declaration
+                any:
+                  - has:
+                      kind: getter
+                  - has:
+                      kind: setter
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - readability
+examples:
+  bad: |
+    class Point(val x: Int, val y: Int)
+  good: |
+    data class Point(val x: Int, val y: Int)

package/node_modules/pi-lens/rules/ast-grep-rules/rules/kotlin-prefer-is-empty.yml

@@ -0,0 +1,35 @@
+# Kotlin Prefer isEmpty
+# Detects `.size == 0` / `.length == 0`, which usually reads better as
+# `.isEmpty()`.
+# Ported from vinhnx/VTCode rules/kotlin/prefer-is-empty.yml (#2198, refs #2195).
+id: kotlin-prefer-is-empty
+language: kotlin
+severity: warning
+message: "Use isEmpty() instead of comparing size/length to zero"
+note: |
+  `.isEmpty()` states intent directly. It is exactly equivalent to a
+  zero-size/zero-length comparison for every Kotlin collection, Array, and
+  String, but this rule cannot see the receiver's actual type — a class with
+  its own unrelated `size`/`length` property (e.g. `class Segment(val
+  length: Int)`) has no `isEmpty()` member at all, so a blind rewrite would
+  emit code that doesn't compile.
+  Detection-only for that reason, matching the Java sibling
+  `prefer-string-is-empty.yml`: the receiver's type is not checked here
+  either. Only the exact `== 0` comparison is flagged; `> 0`, `!= 0`, and
+  other comparisons are left alone because their natural rewrite
+  (isNotEmpty, or none) differs per shape.
+rule:
+  any:
+    - pattern: $RECEIVER.size == 0
+    - pattern: $RECEIVER.length == 0
+files:
+  - "**/*.kt"
+tags:
+  - kotlin
+  - idiom
+  - readability
+examples:
+  bad: |
+    if (items.size == 0) return
+  good: |
+    if (items.isEmpty()) return

package/node_modules/pi-lens/rules/ast-grep-rules/rules/no-important.yml

@@ -0,0 +1,21 @@
+id: no-important
+language: Css
+severity: warning
+message: "Avoid `!important` — increase selector specificity instead"
+note: |
+  Ported from VTCode (https://github.com/vinhnx/VTCode/tree/main/rules/css,
+  Apache-2.0 license) per #2199 / #2195.
+
+  `!important` overrides normal cascade order and makes CSS harder to
+  maintain: once one declaration reaches for it, overriding it later
+  requires either another `!important` or a `style` attribute, and the
+  arms race compounds. Prefer raising selector specificity or restructuring
+  the cascade so the intended rule already wins.
+
+  Detection-only: a safe fix would need to know which selector should win
+  and why, which this rule cannot infer from the declaration alone. Ported
+  as-is from upstream (no fix upstream either).
+rule:
+  pattern: "!important"
+files:
+  - "**/*.css"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/no-raw-types.yml

@@ -0,0 +1,33 @@
+id: no-raw-types
+language: java
+severity: warning
+message: Use parameterized types instead of raw types.
+note: Ported from VTCode (https://github.com/vinhnx/VTCode), refs #2195. Raw collection types need a project/API-aware generic choice, so this rule is detection-only. Contexts with no valid parameterized form are excluded.
+rule:
+  kind: type_identifier
+  regex: "^(List|Map|Set|Collection|Iterator|Iterable|Queue|Deque|Optional)$"
+  not:
+    any:
+      # Already parameterized. These carry no `stopBy`, so they test only the
+      # immediate parent. `stopBy: end` walked every ancestor instead, which
+      # silenced a raw type nested in a type argument: in `Map<String, List>`
+      # the inner `List` has a generic_type ancestor and went unreported.
+      - inside:
+          kind: generic_type
+      # The qualifier chain of a parameterized qualified type, so
+      # `java.util.List<String>` and `Map.Entry<K, V>` stay silent.
+      - inside:
+          kind: scoped_type_identifier
+          inside:
+            kind: generic_type
+      # `o instanceof List` and `List.class` have no valid parameterized form.
+      # `o instanceof List<String>` and `List<String>.class` are both compile
+      # errors, so a finding here is unactionable.
+      - inside:
+          kind: instanceof_expression
+      - inside:
+          kind: class_literal
+files:
+  - "**/*.java"
+ignores:
+  - "**/test/**"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/no-string-concat-in-loop.yml

@@ -0,0 +1,90 @@
+id: no-string-concat-in-loop
+language: java
+severity: warning
+message: Use StringBuilder instead of string concatenation in loops.
+note: Ported from VTCode (https://github.com/vinhnx/VTCode), refs #2195. Loop allocation and readability context make this detection-only. The accumulator must be a String, established either by a direct string-literal operand or by the declaration that binds the same name in scope.
+rule:
+  all:
+    # An accumulating assignment: `s += x` or `s = s + x`.
+    - any:
+        - pattern: $VAR += $EXPR
+        - pattern: $VAR = $VAR + $EXPR
+    # ... inside a loop body.
+    - any:
+        - inside:
+            kind: for_statement
+            stopBy: end
+        - inside:
+            kind: enhanced_for_statement
+            stopBy: end
+        - inside:
+            kind: while_statement
+            stopBy: end
+        - inside:
+            kind: do_statement
+            stopBy: end
+    # ... where the accumulator is a String. Without this arm the rule fires on
+    # `total += counts.get("label")`, because a `stopBy: end` search for a
+    # string_literal accepts one anywhere in the subtree, including inside a
+    # call argument. Each branch below binds String-ness to $VAR itself.
+    - any:
+        # The right-hand side is, or directly contains, a string literal. The
+        # inner `has` carries no `stopBy`, so it only inspects direct operands
+        # of the `+` and never descends into a call's arguments.
+        - has:
+            field: right
+            any:
+              - kind: string_literal
+              - all:
+                  - kind: binary_expression
+                  - has:
+                      kind: string_literal
+        # $VAR is declared String in the enclosing method or constructor,
+        # either as a local or as a parameter. $VAR is the same metavariable
+        # the pattern above bound, so the names must match.
+        - inside:
+            stopBy: end
+            any:
+              - kind: method_declaration
+              - kind: constructor_declaration
+            has:
+              stopBy: end
+              any:
+                - all:
+                    - kind: local_variable_declaration
+                    - has:
+                        field: type
+                        regex: ^String$
+                    - has:
+                        kind: variable_declarator
+                        has:
+                          field: name
+                          pattern: $VAR
+                - all:
+                    - kind: formal_parameter
+                    - has:
+                        field: type
+                        regex: ^String$
+                    - has:
+                        field: name
+                        pattern: $VAR
+        # $VAR is a String field of the enclosing class.
+        - inside:
+            stopBy: end
+            kind: class_body
+            has:
+              stopBy: end
+              all:
+                - kind: field_declaration
+                - has:
+                    field: type
+                    regex: ^String$
+                - has:
+                    kind: variable_declarator
+                    has:
+                      field: name
+                      pattern: $VAR
+files:
+  - "**/*.java"
+ignores:
+  - "**/test/**"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/no-system-out-println.yml

@@ -0,0 +1,16 @@
+id: no-system-out-println
+language: java
+severity: warning
+message: Avoid System.out.println; use a logging framework instead.
+note: Ported from VTCode (https://github.com/vinhnx/VTCode), refs #2195. Logger policy and intentional console output vary by project, so this rule is detection-only.
+rule:
+  any:
+    - pattern: System.out.println($$$)
+    - pattern: System.out.print($$$)
+    - pattern: System.err.println($$$)
+    - pattern: System.err.print($$$)
+files:
+  - "**/*.java"
+ignores:
+  - "**/test/**"
+  - "**/*Test.java"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/prefer-string-is-empty.yml

@@ -0,0 +1,11 @@
+id: prefer-string-is-empty
+language: java
+severity: warning
+message: Use .isEmpty() instead of .length() == 0 or .equals("").
+note: Ported from VTCode (https://github.com/vinhnx/VTCode), refs #2195. The receiver's type is not checked, so this rule is detection-only. Detection is limited to the exact empty-string and zero-length forms.
+rule:
+  any:
+    - pattern: $S.length() == 0
+    - pattern: $S.equals("")
+files:
+  - "**/*.java"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/python-optional-type.yml

@@ -0,0 +1,22 @@
+id: python-optional-type
+language: Python
+severity: hint
+message: "Optional[T] requires Python 3.10+ to rewrite as T | None"
+note: |
+  `Optional[T]` can be written as `T | None` on Python 3.10 and later.
+  A CPython 3.11 stdlib census found 1,675 matches and zero defects, so this
+  remains a modernization hint rather than a warning about incorrect code.
+  This rule is detection-only because the target project's Python version is
+  not available to a syntax-only matcher. Do not apply the rewrite to Python
+  3.8 or 3.9 code.
+rule:
+  kind: type
+  regex: '^(Optional|typing\.Optional|t\.Optional)\['
+has_fix: false
+tags:
+  - python
+  - typing
+  - modernization
+examples:
+  bad: "value: Optional[str]"
+  good: "value: str | None"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/reducible-list-comprehension.yml

@@ -0,0 +1,29 @@
+id: reducible-list-comprehension
+language: Python
+severity: warning
+message: "A list comprehension is unnecessary here; use a generator expression"
+note: |
+  `any`, `all`, and `sum` consume iterables directly, so the list allocation
+  can be removed without changing the operation's result. The generator
+  expression can short-circuit, so evaluation counts differ; apply this fix
+  only when the element expression is side-effect-free.
+rule:
+  pattern: $FN([$X for $Y in $Z])
+  not:
+    any:
+      - pattern: $FN([$X async for $Y in $Z])
+      - pattern: $FN([await $X for $Y in $Z])
+      - has:
+          pattern: await $$$
+          stopBy: end
+constraints:
+  FN:
+    regex: "^(any|all|sum)$"
+fix: "$FN($X for $Y in $Z)"
+tags:
+  - python
+  - performance
+  - modernization
+examples:
+  bad: "total = sum([price for price in prices])"
+  good: "total = sum(price for price in prices)"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/ruby-symbol-to-proc-candidate.yml

@@ -0,0 +1,25 @@
+id: ruby-symbol-to-proc-candidate
+language: Ruby
+severity: warning
+message: "Use a symbol-to-proc shorthand for this simple iterator block"
+note: |
+  A block that forwards its one parameter to one receiver method can use the
+  equivalent symbol-to-proc form. Side-effect-oriented iterators such as
+  `each` are excluded because replacing them is less useful as a default hint.
+rule:
+  pattern: $LIST.$ITER { |$X| $X.$METHOD }
+  not:
+    pattern: $LIST.$ITER { |$X| $X.$METHOD($$$ARGS) }
+constraints:
+  ITER:
+    regex: '^(map|collect|filter|select|reject|find|detect|any\?|all\?|none\?|one\?|flat_map|sort_by|group_by)$'
+  METHOD:
+    regex: '^[A-Za-z_][A-Za-z0-9_]*[?!=]?$'
+fix: "$LIST.$ITER(&:$METHOD)"
+tags:
+  - ruby
+  - style
+  - modernization
+examples:
+  bad: "names.map { |name| name.upcase }"
+  good: "names.map(&:upcase)"

package/node_modules/pi-lens/rules/ast-grep-rules/rules/rust-no-chars-enumerate.yml

@@ -0,0 +1,19 @@
+id: rust-no-chars-enumerate
+language: Rust
+severity: warning
+message: "chars().enumerate() may confuse character indices with byte offsets"
+note: |
+  `chars().enumerate()` produces character positions, while many Rust APIs
+  require byte offsets. This rule is detection-only because the intended index
+  semantics cannot be proved from syntax. Use `char_indices()` only when the
+  consumer requires byte offsets.
+rule:
+  pattern: $TEXT.chars().enumerate()
+has_fix: false
+tags:
+  - rust
+  - correctness
+  - unicode
+examples:
+  bad: "for (index, character) in text.chars().enumerate() {}"
+  good: "for (index, character) in text.char_indices() {}"