@sister.software/oxlint-config 9.2.0 → 10.0.0

package/src/index.ts

@@ -12,6 +12,76 @@ export * from "./restrictions.js"
 /** An oxlint configuration object, as consumed by `oxlint.config.ts` / `.oxlintrc.json`. */
 export type OxlintConfig = Record<string, unknown>
 
+/** Numeric ceilings for the legibility-guardrail rules. Each is a hard ceiling, not a target. */
+export interface OxlintConfigLimits {
+	/** Maximum block nesting depth. */
+	maxDepth: number
+	/** Maximum parameters on a single function. */
+	maxParams: number
+	/** Maximum statements in a single function body. */
+	maxStatements: number
+	/** Maximum lines in a single function body, blank lines and comments excluded. */
+	maxLinesPerFunction: number
+	/** Maximum lines in a single file, blank lines and comments excluded. */
+	maxLines: number
+	/** Maximum nested callback depth. */
+	maxNestedCallbacks: number
+	/** Maximum nested call-expression depth, e.g. `a(b(c(d())))`. */
+	maxNestedCalls: number
+	/** Maximum cyclomatic complexity of a single function. */
+	complexity: number
+}
+
+/**
+ * Calibrated against the mailwoman corpus (1,048 non-test source files). Each value sits just past the knee in that
+ * repo's distribution, so considered human code stays silent and runaway generation does not. See the design spec for
+ * the full sweep.
+ *
+ * The four SIZE ceilings are deliberately looser than the knee. Adopting v10 surfaced 172 pre-existing violations, and
+ * splitting that many functions across a parser — with no accuracy gate available to verify the result — is a larger
+ * risk than the legibility it buys. They are set at the p90 of the measured overage instead, so the worst decile had to
+ * be fixed at adoption while the body was grandfathered:
+ *
+ *     max-statements          n=88  median= 73  p90= 115  max= 272
+ *     complexity              n=32  median= 49  p90=  84  max= 173
+ *     max-lines-per-function  n=26  median=283  p90= 829  max=1329
+ *     max-params              n=15  median=  7  p90=   8  max=  10
+ *
+ * RATCHET THESE DOWN as the grandfathered functions are split. They exist to stop new code drifting, and every step
+ * toward the knee makes them do more of that job.
+ */
+export const DefaultLimits: OxlintConfigLimits = {
+	maxDepth: 5,
+	maxParams: 8,
+	maxStatements: 115,
+	maxLinesPerFunction: 830,
+	maxLines: 750,
+	maxNestedCallbacks: 4,
+	maxNestedCalls: 4,
+	complexity: 85,
+}
+
+/** Globs treated as test files, where the size and named-constant rules are switched off. */
+export const DefaultTestFilePatterns = [
+	"**/*.test.ts",
+	"**/*.test.tsx",
+	"**/test/**",
+	"**/fixtures/**",
+	"**/*.bench.ts",
+	// Storybook stories are fixtures in the same sense: each export is a rendered case, and its NAME is
+	// the label shown in the sidebar. A JSDoc block on `export const Default: Story = {}` says nothing
+	// the name does not.
+	"**/*.stories.ts",
+	"**/*.stories.tsx",
+]
+
+/**
+ * Globs whose contents are emitted by a generator, not written by hand. The size ceilings are meaningless there — the
+ * file is as long as its input is wide, and no reviewer reads it top to bottom — but every correctness rule still
+ * applies, because generated code ships.
+ */
+export const DefaultGeneratedFilePatterns = ["**/*.gen.ts", "**/*.gen.tsx", "**/*.generated.ts", "**/generated/**"]
+
 /** Options for {@link createOxlintConfig}. */
 export interface OxlintConfigOptions {
 	/** The package namespace whose runtime boundaries are enforced, e.g. `@sister.software`. */
@@ -30,13 +100,36 @@ export interface OxlintConfigOptions {
 	padding?: boolean
 	/** Require braces around single-statement work bodies (bare `return` exempt; on by default). */
 	braces?: boolean
+	/**
+	 * Forbid direct `process.env` / `process.argv` access (off by default). Turn on once the project funnels those reads
+	 * through blessed helpers, which disable `sister-software/no-process-globals`.
+	 */
+	restrictProcessGlobals?: boolean
+	/**
+	 * Flag numeric literals used as comparison thresholds (off by default). Pass an object to change the ignore list or
+	 * to stop exempting radix-prefixed literals.
+	 */
+	unnamedThresholds?: boolean | { ignore?: number[]; allowHex?: boolean }
+	/**
+	 * Require a JSDoc block on module-level constants (off by default). `scope` selects which ones: `"exported"`,
+	 * `"screaming"`, or the default `"exported-or-screaming"`.
+	 */
+	constantDocs?: boolean | { scope?: "exported" | "screaming" | "exported-or-screaming" }
+	/** Rewrite explicit length comparisons to truthiness in boolean positions (on by default). */
+	lengthTruthiness?: boolean
+	/** Override individual legibility ceilings. Unspecified keys keep their calibrated default. */
+	limits?: Partial<OxlintConfigLimits>
+	/** Replace the globs treated as test files. */
+	testFilePatterns?: string[]
+	/** Replace the globs treated as generated files, where only the size ceilings are switched off. */
+	generatedFilePatterns?: string[]
 	/** Override the default ignore patterns. */
 	ignorePatterns?: string[]
 	/** Extra config deep-merged last; an escape hatch for per-repo tweaks. */
 	overrides?: OxlintConfig
 }
 
-/** Default ignore patterns for generated/build output. */
+/** Default ignore patterns for generated/build output and vendored tooling. */
 export const DefaultIgnorePatterns = [
 	"**/out",
 	"**/dist",
@@ -44,6 +137,9 @@ export const DefaultIgnorePatterns = [
 	"**/node_modules",
 	"**/coverage",
 	"**/storybook-static",
+	// Yarn 4 vendors its own release bundle and plugin code here. It is third-party, minified, and
+	// not ours to lint — Tier 2's `no-abusive-eslint-disable` fires on it otherwise.
+	"**/.yarn/**",
 ]
 
 /**
@@ -70,18 +166,26 @@ export function createOxlintConfig(options: OxlintConfigOptions = {}): OxlintCon
 		headers = true,
 		padding = true,
 		braces = true,
+		restrictProcessGlobals = false,
+		unnamedThresholds = false,
+		constantDocs = false,
+		lengthTruthiness = true,
+		limits: limitOverrides = {},
+		testFilePatterns = DefaultTestFilePatterns,
+		generatedFilePatterns = DefaultGeneratedFilePatterns,
 		ignorePatterns = DefaultIgnorePatterns,
 		overrides = {},
 	} = options
 
-	const plugins = ["typescript", "unicorn", "oxc", ...(react ? ["react"] : [])]
+	const limits: OxlintConfigLimits = { ...DefaultLimits, ...limitOverrides }
+
+	const plugins = ["typescript", "unicorn", "oxc", "import", "promise", "vitest", ...(react ? ["react"] : [])]
 
 	const rules: Record<string, unknown> = {
 		// JavaScript
 		eqeqeq: ["error", "always", { null: "ignore" }],
 		"prefer-const": "warn",
 		"object-shorthand": ["warn", "always"],
-		"no-shadow": "off",
 		"no-undef": "off",
 		"no-unused-vars": [
 			"warn",
@@ -107,6 +211,191 @@ export function createOxlintConfig(options: OxlintConfigOptions = {}): OxlintCon
 		"typescript/no-non-null-assertion": "off",
 		"typescript/no-var-requires": "off",
 		"typescript/no-require-imports": "off",
+
+		// Tier 1 — legibility guardrails. Thresholds are ceilings past the knee of the calibration
+		// corpus's distribution: they stay silent on considered code and fire on runaway generation.
+		"max-depth": ["error", { max: limits.maxDepth }],
+		"max-params": ["error", { max: limits.maxParams }],
+		"max-statements": ["error", { max: limits.maxStatements }],
+		"max-lines-per-function": ["error", { max: limits.maxLinesPerFunction, skipBlankLines: true, skipComments: true }],
+		"max-lines": ["error", { max: limits.maxLines, skipBlankLines: true, skipComments: true }],
+		"max-nested-callbacks": ["error", { max: limits.maxNestedCallbacks }],
+		"unicorn/max-nested-calls": ["error", { max: limits.maxNestedCalls }],
+		complexity: ["error", limits.complexity],
+		"unicorn/no-array-reduce": "error",
+		"unicorn/no-unreadable-array-destructuring": "error",
+
+		// Tier 2 — defect classes that `correctness` does not cover. Every rule here corresponds to a
+		// way working-looking code is wrong at runtime.
+		"no-shadow": "error",
+		"no-promise-executor-return": "error",
+		"no-useless-assignment": "error",
+		"no-unreachable-loop": "error",
+		"no-unmodified-loop-condition": "error",
+		"no-loop-func": "error",
+		// `.sort()` and `.reverse()` mutate in place; on a shared or cached array that is a bug at a
+		// distance. The fixes are `toSorted()` / `toReversed()`.
+		"unicorn/no-array-sort": "error",
+		"unicorn/no-array-reverse": "error",
+		"unicorn/no-immediate-mutation": "error",
+		"unicorn/no-array-method-this-argument": "error",
+		"unicorn/no-typeof-undefined": "error",
+		"unicorn/no-useless-promise-resolve-reject": "error",
+		"unicorn/prefer-type-error": "error",
+		// Global `isNaN` coerces its argument; `Number.isNaN` does not.
+		"unicorn/prefer-number-properties": "error",
+		"unicorn/no-abusive-eslint-disable": "error",
+		// Off despite the name: it fires on `.map(x => ({ ...x, field }))`, which is O(n·k) overall and the
+		// ordinary way to add a field. The quadratic accumulation worth catching is `acc = { ...acc, x }`
+		// inside a reduce, which this does not distinguish. 14 sites, 14 false positives.
+		"oxc/no-map-spread": "off",
+		"oxc/bad-bitwise-operator": "error",
+		"oxc/branches-sharing-code": "error",
+		"typescript/no-dynamic-delete": "error",
+		"typescript/prefer-ts-expect-error": "error",
+		// A cycle here is not a style issue: it leaves bindings unevaluated at import time, which
+		// surfaces as a base class that is `undefined` at class-definition time.
+		"import/no-cycle": "error",
+		// `ignoreLastCallback` keeps the rule pointed at CHAINS, where a missing return silently feeds
+		// undefined to the next link. A terminal `.then(…)` doing side effects has nothing downstream
+		// to starve, and rewriting those adds a return whose value no one reads.
+		"promise/always-return": ["error", { ignoreLastCallback: true }],
+		// Off: it cannot see that a ternary settles exactly once. `cb((err) => (err ? reject(err) : resolve()))`
+		// is the standard way to bridge a node-style callback to a promise, and the rule flagged every
+		// instance of it on the calibration corpus — 6 sites, 6 false positives, no real double-settle.
+		"promise/no-multiple-resolved": "off",
+
+		// Tier 3 — test discipline. `expect-expect` is the one that matters most: it catches a test
+		// that runs, passes, and asserts nothing.
+		"vitest/expect-expect": "error",
+		// vitest's `expect(value, message)` takes an optional assertion message as a second argument —
+		// the rule's default of one would flag the API's own signature.
+		"vitest/valid-expect": ["error", { maxArgs: 2 }],
+		"vitest/valid-title": "error",
+		"vitest/valid-describe-callback": "error",
+		// Off: the dominant shape it flags is a parameterized assertion helper, where the conditional IS
+		// the contract — `expectProposal(out, { kind, body, minConfidence? })` asserts only what the
+		// caller specified. 33 sites on the calibration corpus, none a hidden never-running assertion.
+		"vitest/no-conditional-expect": "off",
+		"vitest/no-conditional-tests": "error",
+		"vitest/no-disabled-tests": "error",
+		"vitest/no-commented-out-tests": "error",
+		"vitest/no-alias-methods": "error",
+		"vitest/prefer-to-be": "error",
+		"vitest/prefer-to-have-length": "error",
+		"vitest/prefer-to-contain": "error",
+		"vitest/require-to-throw-message": "error",
+		// Playwright names its e2e specs `*.spec.ts`; vitest unit tests are `*.test.ts`. A repo running
+		// both has two legitimate conventions, so the rule is scoped to the vitest ones.
+		"vitest/consistent-test-filename": ["error", { allTestPattern: String.raw`.*\.test\.[tj]sx?$` }],
+		// Enabling a plugin also activates its `correctness`-category rules, so a rule this tier turned
+		// down must be switched off explicitly rather than merely left out of the list above.
+		"vitest/require-mock-type-parameters": "off",
+		"vitest/no-conditional-in-test": "off",
+
+		// Tier 4 — mechanical hygiene. All autofixable, none requiring judgment.
+		// Literal form.
+		"unicorn/numeric-separators-style": "error",
+		"unicorn/no-zero-fractions": "error",
+		"unicorn/text-encoding-identifier-case": "error",
+		"unicorn/escape-case": "error",
+		"unicorn/no-hex-escape": "error",
+		// Import discipline.
+		// `disallowTypeAnnotations: false` keeps the valuable half — a type-only import must be written
+		// `import type` — while allowing `typeof import("…")` in an annotation. That form is how a
+		// guarded dynamic import is typed: the module is optional and loaded at runtime, and the inline
+		// annotation is what says so. `import type` would erase to nothing and read as a hard dep.
+		"typescript/consistent-type-imports": ["error", { disallowTypeAnnotations: false }],
+		"typescript/no-import-type-side-effects": "error",
+		"unicorn/prefer-export-from": "error",
+		"import/no-duplicates": "error",
+		"import/first": "error",
+		"import/newline-after-import": "error",
+		// Modern API preference.
+		"unicorn/prefer-string-replace-all": "error",
+		// `caught` is permitted alongside `error`: when a catch sits inside a scope that already binds
+		// `error` (a React component's error state, say), no-shadow requires a different name and this
+		// rule would otherwise demand the shadowing one. The two rules are in direct conflict without it.
+		"unicorn/catch-error-name": ["error", { ignore: ["caught"] }],
+		"unicorn/prefer-at": "error",
+		"unicorn/prefer-global-this": "error",
+		"unicorn/consistent-existence-index-check": "error",
+		"unicorn/new-for-builtins": "error",
+		"unicorn/prefer-array-find": "error",
+		"unicorn/prefer-structured-clone": "error",
+		"unicorn/prefer-negative-index": "error",
+		"unicorn/prefer-math-min-max": "error",
+		"unicorn/no-useless-collection-argument": "error",
+		"unicorn/throw-new-error": "error",
+		// Two rules that look mechanical but are not type-safe, so they stay off:
+		//
+		// `unicorn/prefer-code-point` rewrites `charCodeAt` to `codePointAt`, which returns
+		// `number | undefined`. It exists for surrogate-pair correctness, but on the ASCII arithmetic
+		// where it usually fires it buys nothing and forces an undefined branch at every site.
+		//
+		// `unicorn/no-useless-undefined` drops an explicitly-passed `undefined` argument. oxlint has no
+		// type information, so it cannot tell an optional parameter from a required one and will
+		// silently turn `f(a, undefined)` into a call that no longer type-checks.
+		//
+		// `unicorn/prefer-string-raw` rewrites a string literal to a String.raw template. That is
+		// runtime-identical but not type-identical: the literal type is lost, so any template-literal
+		// type built from the value collapses. It widens types silently, which is worse than the
+		// escaped backslashes it removes.
+		"unicorn/prefer-code-point": "off",
+		"unicorn/no-useless-undefined": "off",
+		"unicorn/prefer-string-raw": "off",
+		//
+		// `unicorn/prefer-math-trunc` is the one that is not merely type-unsafe but semantically wrong.
+		// `x | 0` and `x >>> 0` are int32/uint32 coercion, and the wrapping is the point — every site on
+		// the calibration corpus was a hash function, a PRNG, or a seeded evaluation harness.
+		// `Math.trunc` does not wrap, so taking its suggestion silently changes what those produce.
+		"unicorn/prefer-math-trunc": "off",
+		//
+		// `unicorn/prefer-number-coercion` rewrites `Number.parseInt(x, 10)` to
+		// `Math.trunc(Number(x))`. parseInt parses a numeric PREFIX; Number is strict, so
+		// `parseInt("12px", 10)` is 12 where `Number("12px")` is NaN. On the calibration corpus the
+		// inputs included CLI options and an HTTP status of uncertain type — exactly where the
+		// difference bites. It also reintroduces Math.trunc, disabled just above.
+		"unicorn/prefer-number-coercion": "off",
+		//
+		// These two are not unsafe — they are unsatisfiable. oxfmt reverts both fixes on its next run:
+		// it lowercases hex digits, and it strips the parentheses unicorn/no-nested-ternary adds. Lint
+		// and format are both CI gates, so a rule the formatter undoes can never go green. Neither
+		// behaviour is configurable in oxfmt today.
+		"unicorn/number-literal-case": "off",
+		"unicorn/no-nested-ternary": "off",
+		//
+		// `unicorn/explicit-length-check` enforces `x.length > 0`, the opposite of the house
+		// convention. `sister-software/prefer-length-truthiness` enforces ours.
+		"unicorn/explicit-length-check": "off",
+		//
+		// Core `no-duplicate-imports` is not TypeScript-aware: it counts a value import and an
+		// `import type` from the same module as a duplicate, which is the split
+		// `typescript/consistent-type-imports` exists to create. On the calibration corpus it reported
+		// 71 sites where the TS-aware `import/no-duplicates` reported 1, and that 1 was real.
+		"no-duplicate-imports": "off",
+
+		// TS style.
+		"typescript/consistent-type-definitions": "error",
+		"typescript/consistent-indexed-object-style": "error",
+		"typescript/prefer-for-of": "error",
+		"typescript/no-inferrable-types": "error",
+		// Small structural.
+		"unicorn/prefer-ternary": "error",
+		"unicorn/prefer-logical-operator-over-ternary": "error",
+		"unicorn/no-lonely-if": "error",
+		"unicorn/no-console-spaces": "error",
+		"unicorn/no-static-only-class": "error",
+		"no-useless-return": "error",
+	}
+
+	if (react) {
+		rules["react-hooks/rules-of-hooks"] = "error"
+		rules["react/no-unstable-nested-components"] = "error"
+		rules["react/no-object-type-as-default-prop"] = "error"
+		rules["react/jsx-no-constructed-context-values"] = "error"
+		// The automatic JSX runtime made this obsolete; the rule predates it.
+		rules["react/react-in-jsx-scope"] = "off"
 	}
 
 	if (headers) {
@@ -125,13 +414,73 @@ export function createOxlintConfig(options: OxlintConfigOptions = {}): OxlintCon
 		rules["sister-software/require-braces"] = "warn"
 	}
 
+	if (restrictProcessGlobals) {
+		// Error severity: a governance gate — direct env/argv access should fail the lint.
+		rules["sister-software/no-process-globals"] = "error"
+	}
+
+	if (unnamedThresholds) {
+		// Error severity: an unnamed threshold is a legibility defect, not a style preference.
+		rules["sister-software/no-unnamed-threshold"] = [
+			"error",
+			typeof unnamedThresholds === "object" ? unnamedThresholds : {},
+		]
+	}
+
+	if (constantDocs) {
+		// Error severity: an undocumented public constant or tuning knob is a legibility defect.
+		rules["sister-software/require-constant-doc"] = ["error", typeof constantDocs === "object" ? constantDocs : {}]
+	}
+
+	if (lengthTruthiness) {
+		rules["sister-software/prefer-length-truthiness"] = "error"
+	}
+
+	// Rules switched off inside test files. Table-driven test bodies are legitimately long, and
+	// expected values are legitimately unnamed numbers. oxlint validates override entries against the
+	// registered rule set, so an entry may only name a rule this config actually turned on.
+	const testFileRules: Record<string, unknown> = {
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		"max-lines": "off",
+	}
+
+	if (react) {
+		// A Storybook `render` IS a component — React calls it as one — but it is not NAMED like one, so
+		// the hook rules read it as a plain function. Test files that render hooks go through a
+		// testing-library wrapper for the same reason.
+		testFileRules["react-hooks/rules-of-hooks"] = "off"
+	}
+
+	if (unnamedThresholds) {
+		testFileRules["sister-software/no-unnamed-threshold"] = "off"
+	}
+
+	if (constantDocs) {
+		testFileRules["sister-software/require-constant-doc"] = "off"
+	}
+
+	/** Generated files: size ceilings only. Everything else still applies — generated code ships. */
+	const generatedFileRules: Record<string, unknown> = {
+		"max-lines": "off",
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		complexity: "off",
+	}
+
 	return {
 		plugins,
-		...(headers || padding || braces ? { jsPlugins: ["@sister.software/oxlint-config/plugin"] } : {}),
+		...(headers || padding || braces || restrictProcessGlobals || unnamedThresholds || constantDocs || lengthTruthiness
+			? { jsPlugins: ["@sister.software/oxlint-config/plugin"] }
+			: {}),
 		categories: { correctness: "error" },
 		ignorePatterns,
 		rules,
-		overrides: createRuntimeOverrides(packageNamespace),
+		overrides: [
+			...createRuntimeOverrides(packageNamespace),
+			{ files: testFilePatterns, rules: testFileRules },
+			{ files: generatedFilePatterns, rules: generatedFileRules },
+		],
 		...overrides,
 	}
 }

package/src/length-truthiness-plugin.ts

@@ -0,0 +1,132 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A prefer-length-truthiness rule, authored as an oxlint JS plugin (ESLint v9-compatible API).
+ *   It is the house counterpart to `unicorn/explicit-length-check`, which enforces the opposite
+ *   convention and is therefore off: `if (items.length)` reads better here than
+ *   `if (items.length > 0)`.
+ *
+ *   The rule only fires where the value is ALREADY coerced to a boolean — a condition, a ternary
+ *   test, or the operand of `!` — including through `&&`/`||` nested inside one. Outside those
+ *   positions the comparison is the value itself, and rewriting `const hasItems = items.length > 0`
+ *   would silently change its type from boolean to number.
+ */
+
+import type { AstNode, Fixer, Rule, RuleContext } from "./plugin-types.js"
+
+/** Comparisons meaning "non-empty", which become the bare length. */
+const TRUTHY_FORMS = new Set(["> 0", "!== 0", "!= 0", ">= 1"])
+
+/** Comparisons meaning "empty", which become a negated length. */
+const FALSY_FORMS = new Set(["=== 0", "== 0", "< 1"])
+
+/** Members whose length-ness the rule understands. */
+const LENGTH_PROPERTIES = new Set(["length", "size"])
+
+/** The comparison rendered as `<operator> <literal>`, or null when it is not a length comparison. */
+function classify(node: AstNode): { member: AstNode; negate: boolean } | null {
+	if (node.type !== "BinaryExpression" || !node.operator || !node.left || !node.right) return null
+
+	// Accept both `x.length > 0` and the flipped `0 < x.length`.
+	const flipped: Record<string, string> = { "<": ">", ">": "<", "<=": ">=", ">=": "<=" }
+	let { left, right, operator } = { left: node.left, right: node.right, operator: node.operator }
+
+	if (left.type === "Literal" || left.type === "NumericLiteral") {
+		;[left, right] = [right, left]
+		operator = flipped[operator] ?? operator
+	}
+
+	if (left.type !== "MemberExpression" && left.type !== "StaticMemberExpression") return null
+
+	const property = (left as AstNode & { property?: AstNode }).property
+
+	if (!property || property.type !== "Identifier" || !LENGTH_PROPERTIES.has(property.name ?? "")) return null
+
+	if (right.type !== "Literal" && right.type !== "NumericLiteral") return null
+
+	if (typeof right.value !== "number") return null
+
+	const form = `${operator} ${right.value}`
+
+	if (TRUTHY_FORMS.has(form)) return { member: left, negate: false }
+
+	if (FALSY_FORMS.has(form)) return { member: left, negate: true }
+
+	return null
+}
+
+export const preferLengthTruthinessRule: Rule = {
+	meta: {
+		name: "prefer-length-truthiness",
+		type: "suggestion",
+		fixable: "code",
+		schema: [{ type: "object", additionalProperties: true }],
+	},
+	create(context: RuleContext) {
+		const sourceCode = context.sourceCode ?? context.getSourceCode!()
+		const text = sourceCode.getText()
+
+		function report(node: AstNode) {
+			const hit = classify(node)
+
+			if (!hit) return
+
+			const member = text.slice(hit.member.range[0], hit.member.range[1])
+			const replacement = hit.negate ? `!${member}` : member
+
+			context.report({
+				node,
+				message: `Prefer \`${replacement}\` over an explicit length comparison — the house convention is truthiness.`,
+				fix(fixer: Fixer) {
+					return fixer.replaceTextRange(node.range, replacement)
+				},
+			})
+		}
+
+		/** Walk into a boolean context: logical operands and `!` arguments stay boolean. */
+		function visitCondition(node: AstNode | null | undefined) {
+			if (!node) return
+
+			if (node.type === "LogicalExpression") {
+				visitCondition(node.left)
+				visitCondition(node.right)
+
+				return
+			}
+
+			if (node.type === "UnaryExpression" && node.operator === "!") {
+				visitCondition(node.argument)
+
+				return
+			}
+
+			report(node)
+		}
+
+		return {
+			IfStatement(node) {
+				visitCondition(node.test)
+			},
+			WhileStatement(node) {
+				visitCondition(node.test)
+			},
+			DoWhileStatement(node) {
+				visitCondition(node.test)
+			},
+			ForStatement(node) {
+				visitCondition(node.test)
+			},
+			ConditionalExpression(node) {
+				visitCondition(node.test)
+			},
+			UnaryExpression(node) {
+				if (node.operator === "!") {
+					visitCondition(node.argument)
+				}
+			},
+		}
+	},
+}
+
+export default preferLengthTruthinessRule

package/src/plugin-types.ts

@@ -22,6 +22,29 @@ export interface AstNode {
 	/** `if`/`else` branches, for the require-braces rule. */
 	consequent?: AstNode
 	alternate?: AstNode | null
+	/** Binary/unary operator text, for the threshold rule. */
+	operator?: string
+	/** Binary-expression operands. */
+	left?: AstNode
+	right?: AstNode
+	/** Unary-expression operand. */
+	argument?: AstNode
+	/** A literal's value, and its verbatim source text (`raw` preserves a `0x` prefix). */
+	value?: unknown
+	raw?: string
+	/** `const` / `let` / `var`, for the constant-doc rule. */
+	kind?: string
+	/** Declarators of a variable declaration. */
+	declarations?: AstNode[]
+	/** A declarator's binding identifier and initializer. */
+	id?: AstNode
+	init?: AstNode | null
+	/** An identifier's name. */
+	name?: string
+	/** The condition of an `if`/`while`/`for`/ternary, for the length-truthiness rule. */
+	test?: AstNode | null
+	/** A member expression's accessed property. */
+	property?: AstNode
 }
 
 export interface SourceCode {

package/src/plugin.ts

@@ -7,9 +7,13 @@
  */
 
 import { bracesRule } from "./braces-plugin.js"
+import { requireConstantDocRule } from "./constant-doc-plugin.js"
 import { headerRule } from "./headers-plugin.js"
+import { preferLengthTruthinessRule } from "./length-truthiness-plugin.js"
 import { paddingRule } from "./padding-plugin.js"
 import type { Plugin } from "./plugin-types.js"
+import { noProcessGlobalsRule } from "./process-globals-plugin.js"
+import { noUnnamedThresholdRule } from "./threshold-plugin.js"
 
 const sisterSoftwarePlugin: Plugin = {
 	meta: { name: "sister-software" },
@@ -17,6 +21,10 @@ const sisterSoftwarePlugin: Plugin = {
 		"require-file-header": headerRule,
 		"padding-lines": paddingRule,
 		"require-braces": bracesRule,
+		"no-process-globals": noProcessGlobalsRule,
+		"no-unnamed-threshold": noUnnamedThresholdRule,
+		"require-constant-doc": requireConstantDocRule,
+		"prefer-length-truthiness": preferLengthTruthinessRule,
 	},
 }
 

package/src/process-globals-plugin.ts

@@ -0,0 +1,68 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A no-process-globals rule, authored as an oxlint JS plugin (ESLint v9-compatible API). It
+ *   forbids direct `process.env` / `process.argv` access so those reads can be funneled through a
+ *   few blessed helpers; the helper files disable the rule (`sister-software/no-process-globals`).
+ *   oxlint has no `no-restricted-syntax`, so this is a small dedicated rule instead.
+ */
+
+import type { AstNode, Rule } from "./plugin-types.js"
+
+/** `process` members that must be reached through a blessed helper, not accessed directly. */
+const RESTRICTED_MEMBERS = new Set(["env", "argv"])
+
+interface Identifierish extends AstNode {
+	name?: string
+	value?: unknown
+}
+
+interface MemberNode extends AstNode {
+	object?: Identifierish
+	property?: Identifierish
+	computed?: boolean
+}
+
+/** The accessed member name for `process.env` (identifier) or `process["env"]` (string literal). */
+function accessedMember(node: MemberNode): string | null {
+	const property = node.property
+
+	if (!property) return null
+
+	if (!node.computed && property.type === "Identifier") return property.name ?? null
+
+	if (node.computed && (property.type === "Literal" || property.type === "StringLiteral")) {
+		return typeof property.value === "string" ? property.value : null
+	}
+
+	return null
+}
+
+export const noProcessGlobalsRule: Rule = {
+	meta: {
+		name: "no-process-globals",
+		type: "problem",
+		schema: [{ type: "object", additionalProperties: true }],
+	},
+	create(context) {
+		return {
+			MemberExpression(node) {
+				const member = node as MemberNode
+
+				if (member.object?.type !== "Identifier" || member.object.name !== "process") return
+
+				const name = accessedMember(member)
+
+				if (!name || !RESTRICTED_MEMBERS.has(name)) return
+
+				context.report({
+					node,
+					message: `Direct \`process.${name}\` access is restricted — read it through the project's blessed helper (disable \`sister-software/no-process-globals\` there).`,
+				})
+			},
+		}
+	},
+}
+
+export default noProcessGlobalsRule