@felixarntz/biome 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Felix Arntz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# @felixarntz/biome
+
+Reusable [Biome](https://biomejs.dev) lint rules that make your agent produce better code in fewer review cycles, written as [GritQL plugins](https://biomejs.dev/linter/plugins/). Install the package once and reference the rules from any project's Biome config — either all of them with a single line, or individually as needed — without copying `.grit` files around.
+
+## Rules
+
+| Rule | What it flags |
+| --- | --- |
+| `no-as-unknown-as` | `value as unknown as T` double assertions, which bypass TypeScript's type checking entirely. |
+| `no-in-operator` | The `in` operator, recommending `Object.hasOwn(obj, prop)` (which does not walk the prototype chain). |
+| `prefer-object-parameter` | Functions, methods, and constructors with more than one positional parameter, recommending a single object argument with named parameters instead. A leading TypeScript `this` parameter is not counted. |
+
+## Installation
+
+```sh
+pnpm add -D @felixarntz/biome @biomejs/biome
+```
+
+## Usage
+
+Biome plugins are enabled through the [`plugins`](https://biomejs.dev/reference/configuration/#plugins) array in your `biome.json`. **Biome does not resolve plugin entries as package names** — it only accepts file paths — so the rules are referenced by their path inside `node_modules`.
+
+### All rules at once
+
+The package ships a generated `rules/all.grit` that bundles every rule. Enable the whole set with a single entry:
+
+```jsonc
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
+  "plugins": ["./node_modules/@felixarntz/biome/rules/all.grit"]
+}
+```
+
+### Individual rules
+
+Some of the rules are more opinionated than others. So if you don't want to use all of them, you can pick only the rules you want:
+
+```jsonc
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
+  "plugins": [
+    "./node_modules/@felixarntz/biome/rules/no-in-operator.grit",
+    "./node_modules/@felixarntz/biome/rules/no-as-unknown-as.grit",
+    "./node_modules/@felixarntz/biome/rules/prefer-object-parameter.grit"
+  ]
+}
+```
+
+> **Note on the path.** Plugin paths are resolved relative to the `biome.json` that declares them.
+>
+> The `./node_modules/...` form above assumes your config sits next to the `node_modules` that contains this package — the usual case for a single-package project, and for pnpm, whose symlink at `node_modules/@felixarntz/biome` resolves transparently. In a monorepo where the config and the installed package live in different directories, adjust the relative path accordingly (e.g. `../../node_modules/@felixarntz/biome/rules/all.grit`).
+>
+> This is a current Biome limitation: `extends` resolves npm packages, but `plugins` never does. Until Biome adds package resolution for plugins, the relative file path is the only way to reference them. Track progress in [biomejs/biome discussion #6265](https://github.com/biomejs/biome/discussions/6265).
+
+## `Object.hasOwn` type augmentation
+
+`no-in-operator` steers you toward `Object.hasOwn`, but the built-in TypeScript signature returns a plain `boolean` and therefore doesn't narrow the checked object. This package ships a type augmentation that restores narrowing parity with the `in` operator.
+
+Enable it by importing it once from any `.ts`/`.d.ts` file that is part of your compilation:
+
+```ts
+import "@felixarntz/biome/object-hasown";
+```
+
+Or reference it from `tsconfig.json` (requires `"moduleResolution": "bundler"` or `"node16"`):
+
+```jsonc
+{
+  "compilerOptions": {
+    "types": ["@felixarntz/biome/object-hasown"]
+  }
+}
+```
+
+After that, `Object.hasOwn(obj, "key")` narrows `obj` the same way `"key" in obj` would.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@felixarntz/biome",
+  "version": "0.1.0",
+  "description": "Reusable Biome (GritQL) lint rules that make your agent produce better code in fewer review cycles.",
+  "license": "MIT",
+  "keywords": [
+    "biome",
+    "biomejs",
+    "gritql",
+    "lint",
+    "rules",
+    "linter",
+    "plugin"
+  ],
+  "type": "module",
+  "files": [
+    "rules/",
+    "types/",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    "./object-hasown": {
+      "types": "./types/object-hasown/index.d.ts"
+    }
+  },
+  "homepage": "https://github.com/felixarntz/biome#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/felixarntz/biome.git"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
+    "husky": "^9.1.7",
+    "typescript": "^6.0.3",
+    "ultracite": "7.8.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node scripts/generate-all.mjs",
+    "test": "node scripts/generate-all.mjs && node test/run.mjs",
+    "typecheck": "tsc --noEmit",
+    "check": "ultracite check",
+    "fix": "ultracite fix"
+  }
+}

package/rules/all.grit

@@ -0,0 +1,29 @@
+// AUTO-GENERATED by scripts/generate-all.mjs — do not edit.
+// Combines every rule in rules/*.grit. Run `pnpm build` to regenerate.
+
+language js
+
+or {
+  `$value as unknown as $type` as $expr where {
+    register_diagnostic(span=$expr, message="Avoid `as unknown as $type`. Double assertions through `unknown` bypass TypeScript's type checking entirely. Fix the underlying type mismatch instead.")
+  },
+  `$prop in $obj` as $expr where {
+    register_diagnostic(span=$expr, message="Use `Object.hasOwn($obj, $prop)` instead of the `in` operator. `in` also walks the prototype chain, which is rarely the intended runtime check.")
+  },
+  or {
+    JsParameters(items = $params) where {
+      or {
+        $params <: [TsThisParameter(), $second, $third, ...],
+        and {
+          $params <: [$first, $second, ...],
+          $first <: not TsThisParameter()
+        }
+      },
+      register_diagnostic(span=$params, message="Use a single object argument with named parameters instead of multiple positional parameters. Object parameters keep call sites self-documenting and make argument order irrelevant.")
+    },
+    JsConstructorParameters(parameters = $params) where {
+      $params <: [$first, $second, ...],
+      register_diagnostic(span=$params, message="Use a single object argument with named parameters instead of multiple positional parameters. Object parameters keep call sites self-documenting and make argument order irrelevant.")
+    }
+  }
+}

package/rules/no-as-unknown-as.grit

@@ -0,0 +1,5 @@
+language js
+
+`$value as unknown as $type` as $expr where {
+  register_diagnostic(span=$expr, message="Avoid `as unknown as $type`. Double assertions through `unknown` bypass TypeScript's type checking entirely. Fix the underlying type mismatch instead.")
+}

package/rules/no-in-operator.grit

@@ -0,0 +1,5 @@
+language js
+
+`$prop in $obj` as $expr where {
+  register_diagnostic(span=$expr, message="Use `Object.hasOwn($obj, $prop)` instead of the `in` operator. `in` also walks the prototype chain, which is rarely the intended runtime check.")
+}

package/rules/prefer-object-parameter.grit

@@ -0,0 +1,18 @@
+language js
+
+or {
+  JsParameters(items = $params) where {
+    or {
+      $params <: [TsThisParameter(), $second, $third, ...],
+      and {
+        $params <: [$first, $second, ...],
+        $first <: not TsThisParameter()
+      }
+    },
+    register_diagnostic(span=$params, message="Use a single object argument with named parameters instead of multiple positional parameters. Object parameters keep call sites self-documenting and make argument order irrelevant.")
+  },
+  JsConstructorParameters(parameters = $params) where {
+    $params <: [$first, $second, ...],
+    register_diagnostic(span=$params, message="Use a single object argument with named parameters instead of multiple positional parameters. Object parameters keep call sites self-documenting and make argument order irrelevant.")
+  }
+}

package/types/object-hasown/index.d.ts

@@ -0,0 +1,18 @@
+/*
+ * Augment `Object.hasOwn` with a type predicate so it narrows the input the
+ * same way the `in` operator does. The lib signature returns plain `boolean`,
+ * which means TS cannot narrow after a `hasOwn` check — this restores parity.
+ */
+declare global {
+  interface ObjectConstructor {
+    hasOwn<O extends object, K extends PropertyKey>(
+      // biome-ignore lint/plugin/all: this mirrors the native `Object.hasOwn` signature, whose two positional parameters are fixed by the ECMAScript contract.
+      o: O,
+      v: K
+    ): o is Extract<O, Record<K, unknown>> extends never
+      ? O & Record<K, unknown>
+      : Extract<O, Record<K, unknown>>;
+  }
+}
+
+export {};