@herbertgao/pi-extensions 2026.8.6 → 2026.8.8

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-inner-html-test.yml

@@ -2,7 +2,13 @@ id: no-inner-html
 valid:
   - 'el.textContent = "x"'
   - 'el.insertAdjacentText("beforeend", "x")'
-invalid:
+  - "el.innerHTML = ''"
   - 'el.innerHTML = "x"'
   - 'el.outerHTML = "x"'
+  - 'el.innerHTML = `static markup`'
+invalid:
   - 'el.insertAdjacentHTML("beforeend", "x")'
+  - "el.innerHTML = html"
+  - "el.innerHTML = getHtml(entry, label)"
+  - 'el.innerHTML = `hi ${name}`'
+  - "el.outerHTML = html"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-known-value-widening-test.yml

@@ -0,0 +1,9 @@
+id: no-known-value-widening
+valid:
+  - "const x = { a: 1 };"
+  - "const x: Record<string, number> = other;"
+  - "const x = other as Record<string, number>;"
+  - "const x: Record<string, number> = getDefaults();"
+invalid:
+  - "const x: Record<string, number> = { a: 1 };"
+  - 'const x: Record<string, string> = { a: "b", c: "d" };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-non-null-assertion-test.yml

@@ -3,8 +3,224 @@ valid:
   - 'const x = foo'
   - 'const x = foo?.bar'
   - 'const x: number = foo()'
+  # #1777: get-after-has, same map, same key — suppressed.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (m.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777: pop-after-length, same array, in a while loop.
+  - |
+    function f(stack: number[]) {
+      while (stack.length > 0) {
+        const x = stack.pop()!;
+      }
+    }
+  # #1777: shift-after-length, same array, in an if branch.
+  - |
+    function f(queue: number[]) {
+      if (queue.length > 0) {
+        return queue.shift()!;
+      }
+    }
+  # #1818 round 2: ternary-narrow. The consequence branch is only reached
+  # when the condition's own property access is truthy; the nested closure
+  # loses TS's narrowing across the function boundary, hence the `!`.
+  - |
+    function f(index: { forward?: Map<string, number> }, files: string[]) {
+      return index.forward
+        ? files.map((file) => index.forward!.get(file))
+        : undefined;
+    }
+  # #1818 round 2: property re-asserted after a `.filter()` on the same
+  # property, immediately followed by `.map()` in the same chain.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string } }>) {
+      return reads
+        .filter((r) => r.enclosingSymbol)
+        .map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
 invalid:
   - 'const x = foo!'
   - 'foo!.bar()'
   - 'const x = (foo!)!.bar'
   - 'foo!!'
+  # #1777 mutation guard: a get()! with NO has() check anywhere in the
+  # function must still flag — deleting the exclusion's pattern match
+  # (not just its metavariable binding) reds this.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      return m.get(k)!;
+    }
+  # #1777 mutation guard: the has() check is for a DIFFERENT key —
+  # same-key binding discipline is the guard, not mere presence of
+  # any .has() call on the map.
+  - |
+    function f(m: Map<string, number>, k: string, other: string) {
+      if (m.has(other)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 mutation guard: the has() check is on a DIFFERENT map —
+  # same-receiver binding discipline is the guard.
+  - |
+    function f(m: Map<string, number>, other: Map<string, number>, k: string) {
+      if (other.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 mutation guard: pop()! with NO length check anywhere in the
+  # function must still flag.
+  - |
+    function f(arr: number[]) {
+      return arr.pop()!;
+    }
+  # #1777 mutation guard: the length check is on a DIFFERENT array —
+  # same-array binding discipline is the guard.
+  - |
+    function f(arr: number[], other: number[]) {
+      if (other.length > 0) {
+        return arr.pop()!;
+      }
+    }
+  # #1777: a length check elsewhere in the SAME function that does not
+  # dominate this particular pop() (documented approximation — the
+  # rule only requires presence in the enclosing function, not proven
+  # dominance) still suppresses; this fixture exists to make that
+  # scoping visible rather than silently assumed. Left as `invalid`
+  # because this specific shape (length check AFTER the pop, in an
+  # unrelated later branch) is outside the two named idiom shapes: the
+  # pop here is not itself inside the while/for/if that carries the
+  # length check.
+  - |
+    function f(arr: number[]) {
+      const x = arr.pop()!;
+      if (arr.length > 0) {
+        return x;
+      }
+    }
+  # #1777 F1 regression test: a `.has()` guard in an OUTER function must
+  # NOT suppress a `!` inside an INNER closure — the `stopBy` boundary
+  # has to stop the ancestor walk at the nearest enclosing function.
+  # Review round 1 proved the pre-fix rule got this wrong (a guard in
+  # the outer scope suppressed the closure's finding).
+  - |
+    function outer(m: Map<string, number>, k: string) {
+      if (m.has(k)) {
+        // guard lives here, in the OUTER function
+      }
+      return function inner() {
+        return m.get(k)!;
+      };
+    }
+  # #1777 F1 regression test, arrow-closure variant: same outer/inner
+  # split, `.length` guard in the outer function only.
+  - |
+    function outer(arr: number[]) {
+      if (arr.length > 0) {
+        // guard lives here, in the OUTER function
+      }
+      return () => arr.pop()!;
+    }
+  # #1777 F2 regression test: `if (!m.has(k))` guards the branch where
+  # the key is proven ABSENT, so `m.get(k)!` inside that branch is a
+  # real bug, not a narrowed-after-check idiom. ast-grep can't read
+  # branch polarity, so the fix is a blunt one — ANY negated `.has()`
+  # is refused as a guard — but it MUST catch this exact shape, the one
+  # review round 1 named as "the rule's most likely real bug shape."
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (!m.has(k)) {
+        return m.get(k)!;
+      }
+    }
+  # #1777 F2 accepted regression: this is a genuinely SAFE early-return
+  # guard clause — by the time `m.get(k)!` runs, `!m.has(k)` has already
+  # returned. It was correctly suppressed before the F2 fix. It is NOT
+  # anymore, and that is accepted, not a bug: ast-grep matches this
+  # `if (!m.has(k)) return;` identically to the real-bug shape directly
+  # above (same syntax, opposite control flow), and there is no cheaper
+  # structural signal available to tell them apart. This fixture exists
+  # so the known blind spot has a name and a test, and can't be
+  # mistaken for coverage this rule doesn't have.
+  - |
+    function f(m: Map<string, number>, k: string) {
+      if (!m.has(k)) return;
+      return m.get(k)!;
+    }
+  # #1818 mutation guard: ternary-narrow, but the assertion sits in the
+  # ALTERNATIVE branch (the condition's property is falsy there) — a real
+  # bug, must still flag.
+  - |
+    function f(index: { forward?: Map<string, number> }, files: string[]) {
+      return index.forward
+        ? undefined
+        : files.map((file) => index.forward!.get(file));
+    }
+  # #1818 mutation guard: ternary-narrow, but the assertion targets a
+  # DIFFERENT object than the condition checked — same-binding discipline
+  # is the guard, not mere presence of a truthy-ternary anywhere outside.
+  - |
+    function f(
+      index: { forward?: Map<string, number> },
+      other: { forward?: Map<string, number> },
+      files: string[],
+    ) {
+      return index.forward
+        ? files.map((file) => other.forward!.get(file))
+        : undefined;
+    }
+  # #1818 mutation guard: filter+map, but the filter checks a DIFFERENT
+  # property than the one asserted in map — must still flag.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string }; other?: unknown }>) {
+      return reads
+        .filter((r) => r.other)
+        .map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
+  # #1818 mutation guard: no preceding filter at all — must still flag.
+  - |
+    function f(reads: Array<{ enclosingSymbol?: { name: string } }>) {
+      return reads.map((r) => ({ name: r.enclosingSymbol!.name }));
+    }
+  # #1818 review round 1, N1: the SAME assertion repeated in BOTH the
+  # consequence AND alternative branches. The consequence instance is
+  # genuinely safe and suppressed; the alternative instance is a real
+  # bug (the condition's property is falsy on that branch) and must
+  # still flag. An `has: field: consequence` EXISTENCE check on the
+  # ternary cannot tell these two instances apart (the consequence
+  # branch's matching text satisfies the check for both); `field:
+  # consequence` as an IDENTITY check on the matched node can.
+  - |
+    function f(o: { y?: { length: number } }) {
+      return o.y ? o.y!.length : o.y!.length;
+    }
+  # #1818 review round 1, N2a: nested ternary. The assertion's NEAREST
+  # ternary is the INNER one, whose own condition (`flag`) does not
+  # match the asserted object/property — so it must still flag, even
+  # though an OUTER ternary's condition happens to match. Proves
+  # `stopBy: kind: ternary_expression` is a real boundary: weakening it
+  # to `end` lets the search escalate past the inner ternary (which
+  # correctly fails) to the outer one (which wrongly succeeds).
+  - |
+    function f(o: { y?: { length: number } }, flag: boolean) {
+      return o.y
+        ? flag
+          ? 1
+          : o.y!.length
+        : 0;
+    }
+  # #1818 review round 1, N2b: filter+map, but the asserted receiver is
+  # an UNRELATED variable, not the map callback's own parameter — must
+  # still flag. Proves the `$M` metavariable binding is load-bearing:
+  # decoupling it (e.g. to an unconstrained parameter name) would make
+  # ANY assertion inside ANY filter-then-map chain's callback body
+  # suppress, regardless of what is actually being asserted.
+  - |
+    function f(
+      rs: Array<{ sym?: { name: string } }>,
+      stray: { sym?: { name: string } },
+    ) {
+      return rs.filter((r) => r.sym).map((m) => stray.sym!.name);
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-apply-js-test.yml

@@ -2,6 +2,8 @@ id: no-reflect-apply-js
 valid:
   - 'fn.apply(obj, args)'
   - 'fn(...args)'
+  - 'const proxy = new Proxy(target, { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } });'
 invalid:
   - 'Reflect.apply(fn, obj, args)'
   - 'const r = Reflect.apply(target[method], target, argumentsList);'
+  - 'const ordinary = { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-apply-test.yml

@@ -2,6 +2,8 @@ id: no-reflect-apply
 valid:
   - 'fn.apply(obj, args)'
   - 'fn(...args)'
+  - 'const proxy = new Proxy(target, { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } });'
 invalid:
   - 'Reflect.apply(fn, obj, args)'
   - 'const r = Reflect.apply(target[method], target, argumentsList);'
+  - 'const ordinary = { apply(target, thisArg, args) { return Reflect.apply(target, thisArg, args); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-get-js-test.yml

@@ -2,7 +2,8 @@ id: no-reflect-get-js
 valid:
   - 'obj.prop'
   - 'obj[key]'
-  - 'Reflect.get(target, prop, receiver)'
+  - 'const proxy = new Proxy(api, { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } });'
 invalid:
   - 'Reflect.get(obj, "key")'
   - 'const v = Reflect.get(target, prop);'
+  - 'const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-reflect-get-test.yml

@@ -2,7 +2,8 @@ id: no-reflect-get
 valid:
   - 'obj.prop'
   - 'obj[key]'
-  - 'Reflect.get(target, prop, receiver)'
+  - 'const proxy = new Proxy(api, { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } });'
 invalid:
   - 'Reflect.get(obj, "key")'
   - 'const v = Reflect.get(target, prop);'
+  - 'const ordinary = { get(target, prop, receiver) { return Reflect.get(target, prop, receiver); } };'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-return-value-in-generator-test.yml

@@ -11,6 +11,12 @@ valid:
   - |
     def regular():
         return 42
+  - |
+    @asynccontextmanager
+    async def lifespan(app):
+        def handler():
+            return 42
+        yield
 invalid:
   - |
     def gen():
@@ -20,3 +26,9 @@ invalid:
     def gen():
         yield from iter([1, 2])
         return result
+  - |
+    def outer():
+        def inner_gen():
+            yield 1
+            return 99
+        return inner_gen

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-runtime-typeof-test.yml

@@ -0,0 +1,33 @@
+id: no-runtime-typeof
+valid:
+  - |
+    function isFoo(x: unknown): x is Foo {
+      return typeof x === "object";
+    }
+  - |
+    const isBar = (x: unknown): x is Bar => typeof x === "object";
+  - |
+    function parseThing(x: unknown) {
+      return typeof x === "string";
+    }
+  - |
+    const validateThing = (x: unknown) => typeof x === "string";
+  - |
+    class C {
+      isFoo(x: unknown): x is Foo {
+        return typeof x === "object";
+      }
+    }
+invalid:
+  - |
+    function plain(x: unknown) {
+      return typeof x === "string";
+    }
+  - |
+    const check = (x: unknown) => typeof x === "string";
+  - |
+    class C {
+      plain(x: unknown) {
+        return typeof x === "string";
+      }
+    }

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-server-bind-wildcard-test.yml

@@ -4,7 +4,16 @@ valid:
   - "app.run(host='localhost', port=8000)"
   - "uvicorn.run(app, host='127.0.0.1', port=8000)"
   - "uvicorn.run(app, host=HOST, port=PORT)"  # env var is OK
+  - |
+    return Settings.model_construct(
+        gh_proxy_bind_host='0.0.0.0',
+    )
 invalid:
   - "app.run(host='0.0.0.0', port=8000)"
   - "uvicorn.run(app, host='0.0.0.0', port=8000)"
   - 'app.run(host="0.0.0.0", port=8000)'
+  - "server.listen(host='0.0.0.0', port=8000)"
+  - "app.serve(host='0.0.0.0', port=8000)"
+  - "run(host='0.0.0.0', port=8000)"
+  - "config = uvicorn.Config(app, host='0.0.0.0', port=8000)"
+  - "app.run_server(host='0.0.0.0', port=8000)"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-shape-in-symbol-names-test.yml

@@ -0,0 +1,13 @@
+id: no-shape-in-symbol-names
+valid:
+  - "const manifest = 1;"
+  - "interface I { name: string; }"
+  - "type Manifest = 1;"
+invalid:
+  - "const shape = 1;"
+  - "const packageJsonShape = 1;"
+  - "class C { shapeField = 1; }"
+  - "class C { #shapeField = 1; }"
+  - "interface I { shapeProp: string; }"
+  - "type PackageJsonShape = 1;"
+  - "function reshape() {}"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-sql-in-code-js-test.yml

@@ -3,8 +3,12 @@ valid:
   - "db.find({ id })"
   - "db.findOne({ where: { id } })"
   - 'sql.unsafe("non-sql")'
-invalid:
   - 'db.query("SELECT * FROM users")'
   - 'db.query("INSERT INTO x VALUES (1)")'
   - 'db.query("UPDATE users SET x = 1")'
   - 'db.query("SELECT * FROM users WHERE id = ?", [id])'
+  - 'db.query("SELECT * FROM " + "users")'
+invalid:
+  - 'db.query("SELECT * FROM users WHERE id = " + id)'
+  - 'db.query("DELETE FROM sessions WHERE token = " + token, [])'
+  - 'db.query(`SELECT * FROM users WHERE id = ${id}`)'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-sql-in-code-test.yml

@@ -3,8 +3,12 @@ valid:
   - "db.find({ id })"
   - "db.findOne({ where: { id } })"
   - 'sql.unsafe("non-sql")'
-invalid:
   - 'db.query("SELECT * FROM users")'
   - 'db.query("INSERT INTO x VALUES (1)")'
   - 'db.query("UPDATE users SET x = 1")'
   - 'db.query("SELECT * FROM users WHERE id = ?", [id])'
+  - 'db.query("SELECT * FROM " + "users")'
+invalid:
+  - 'db.query("SELECT * FROM users WHERE id = " + id)'
+  - 'db.query("DELETE FROM sessions WHERE token = " + token, [])'
+  - 'db.query(`SELECT * FROM users WHERE id = ${id}`)'

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unknown-parameters-test.yml

@@ -0,0 +1,12 @@
+id: no-unknown-parameters
+valid:
+  - "function f(x: string) {}"
+  - "function f(cause: unknown) {}"
+  - "const g = (cause?: unknown) => {};"
+  - "class C { m(cause: unknown) {} }"
+invalid:
+  - "function f(x: unknown) {}"
+  - "const g = (x: unknown) => {};"
+  - "class C { m(x: unknown) {} }"
+  - "interface I { m(x: unknown): void; }"
+  - "function f(x?: unknown) {}"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unknown-returns-test.yml

@@ -0,0 +1,16 @@
+id: no-unknown-returns
+valid:
+  - "function f(x: unknown): string { return String(x); }"
+  - "const g = (x: unknown): number => 1;"
+  - "class C { m(): void {} }"
+  # #1824: a function_type is a TYPE-POSITION annotation (a callback
+  # signature or type alias), not a value returning unknown — "the
+  # caller ignores my result" is a legitimate contract, so it must not
+  # flag. Covers both a standalone alias and a parameter position use.
+  - "type H = () => unknown;"
+  - "interface I { on(cb: () => unknown): void; }"
+invalid:
+  - "function f(): unknown { return 1; }"
+  - "const g = (): unknown => 1;"
+  - "class C { m(): unknown { return 1; } }"
+  - "interface I { m(): unknown; }"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unsafe-dictionary-any-test.yml

@@ -0,0 +1,10 @@
+id: no-unsafe-dictionary-any
+valid:
+  - "type T = Record<string, unknown>;"
+  - "function f(x: Record<string, string>) {}"
+  - "interface I { m: Record<string, number>; }"
+invalid:
+  - "type T = Record<string, any>;"
+  - "function f(x: Record<string, any>) {}"
+  - "interface I { m: Record<string, any>; }"
+  - "const m: Record<number, any> = {};"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/no-unsafe-dictionary-unknown-test.yml

@@ -0,0 +1,8 @@
+id: no-unsafe-dictionary-unknown
+valid:
+  - "type T = Record<string, string>;"
+  - "function f(x: Record<string, any>) {}"
+invalid:
+  - "type T = Record<string, unknown>;"
+  - "function f(x: Record<string, unknown>) {}"
+  - "interface I { m: Record<string, unknown>; }"

package/node_modules/pi-lens/rules/ast-grep-rules/rule-tests/redundant-unsafe-function-test.yml

@@ -9,6 +9,16 @@ valid:
     }
   - |
     fn f() -> i32 { 42 }
+  - |
+    /// Dereferences a raw pointer.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure the pointer is valid and aligned.
+    unsafe fn ptr_deref(p: *const i32) -> i32 {
+        let x = 1;
+        x
+    }
 invalid:
   - |
     unsafe fn f() {
@@ -23,3 +33,28 @@ invalid:
         let ptr = 0x1234 as *const i32;
         ptr
     }
+  - |
+    /// Does something.
+    unsafe fn no_real_safety_doc() {
+        println!("nope");
+    }
+  - |
+    // # Safety
+    // This is a stray file-top comment, not attached to any function.
+
+    fn helper() {}
+
+    unsafe fn no_doc_at_all() {
+        println!("bad 1");
+    }
+  - |
+    /// # Safety
+    /// Caller must ensure the pointer is valid.
+    unsafe fn documented_fn(p: *const i32) -> i32 {
+        let x = 1;
+        x
+    }
+
+    unsafe fn undocumented_fn_b() {
+        println!("no doc for me");
+    }