ai-deslop 0.2.0

package/README.md

@@ -0,0 +1,131 @@
+# ai-deslop
+
+Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.
+
+Rules are vendored from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (generic rules) alongside additional deslop rules, all renamed under the `deslop/*` namespace. The vendored source is MIT licensed; see Credits below.
+
+## Install
+
+```bash
+npm install --save-dev ai-deslop
+# @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
+```
+
+Requires a runtime with native TypeScript plugin support: Bun, Deno, or Node.js >= 22.18 / 20.19.
+
+## Usage
+
+Register the plugin in `oxlint.config.ts` and enable every rule as an error via the exported `recommended` config:
+
+```ts
+import { defineConfig } from "oxlint";
+import deslopPlugin, { configs as deslopConfigs } from "ai-deslop";
+
+export default defineConfig({
+  jsPlugins: [deslopPlugin],
+  options: {
+    ...deslopConfigs.recommended.options,
+  },
+  rules: {
+    ...deslopConfigs.recommended.rules,
+  },
+});
+```
+
+The `recommended` config also enables standard type-aware rules (`typescript/no-deprecated`, `typescript/no-floating-promises`), so it sets `options.typeAware`. Type-aware linting requires the `oxlint-tsgolint` package to be installed.
+
+Or with `.oxlintrc.json` (list the rules explicitly):
+
+```json
+{
+  "jsPlugins": ["ai-deslop"],
+  "options": {
+    "typeAware": true
+  },
+  "rules": {
+    "deslop/no-array-filter-map": "error",
+    "deslop/no-reduce-accumulator-copy": "error",
+    "deslop/no-chained-type-assertions": "error",
+    "deslop/no-conditional-empty-object-spread": "error",
+    "deslop/no-known-value-widening": "error",
+    "deslop/no-module-mocking": "error",
+    "deslop/no-object-parameters": "error",
+    "deslop/no-reflect-apply": "error",
+    "deslop/no-reflect-get": "error",
+    "deslop/no-runtime-typeof": "error",
+    "deslop/no-shape-in-symbol-names": "error",
+    "deslop/no-unknown-parameters": "error",
+    "deslop/no-unknown-returns": "error",
+    "deslop/no-unknown-type-aliases": "error",
+    "deslop/no-unsafe-dictionary-type": "error",
+    "deslop/no-widen-then-assert": "error",
+    "deslop/require-safety-comment-for-type-assertion": "error",
+    "deslop/no-call-only-assertions": "error",
+    "deslop/no-pass-through-type-alias": "error",
+    "typescript/no-deprecated": "error",
+    "typescript/no-floating-promises": "error"
+  }
+}
+```
+
+## Rules
+
+### Generic (`deslop/*`)
+
+| Rule | Description |
+| --- | --- |
+| `no-array-filter-map` | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
+| `no-reduce-accumulator-copy` | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
+| `no-chained-type-assertions` | Rejects nested `as` / angle-bracket assertions that fabricate evidence (`as const` chains stay valid). |
+| `no-conditional-empty-object-spread` | Reports object spreads using a conditional `{}` branch to omit fields. |
+| `no-known-value-widening` | Rejects known expressions flowing into explicit `unknown` / `object` / open-dictionary targets. |
+| `no-module-mocking` | Rejects Vitest and Jest `mock` / `doMock` / `unstable_mockModule` calls. |
+| `no-object-parameters` | Rejects `object` (and aliases resolving to it) on function inputs. |
+| `no-reflect-apply` | Rejects global `Reflect.apply` in favor of typed function calls. |
+| `no-reflect-get` | Rejects global `Reflect.get` in favor of typed property access or boundary parsing. |
+| `no-runtime-typeof` | Requires boundary parsing instead of ad hoc `typeof` narrowing (`typeof x === "undefined"` probes stay allowed). |
+| `no-shape-in-symbol-names` | Rejects the case-insensitive substring `shape` in locally owned symbol names. |
+| `no-unknown-parameters` | Rejects `unknown` on function inputs (except the `cause` convention and type-predicate subjects). |
+| `no-unknown-returns` | Rejects function contracts resolving to `unknown` / `Promise<unknown>`. |
+| `no-unknown-type-aliases` | Rejects aliases whose resolved type is `unknown`. |
+| `no-unsafe-dictionary-type` | Rejects dictionary value contracts based on `unknown`, `any`, `object`, `{}`. |
+| `no-widen-then-assert` | Rejects flows that widen known evidence then assert it back to a narrower type. |
+| `require-safety-comment-for-type-assertion` | Requires a nearby invariant justification comment (default marker `SAFETY:`) for each non-const assertion. |
+| `no-call-only-assertions` | Flags tests whose every assertion only checks a mock was called (`toHaveBeenCalledWith` stays allowed). |
+| `no-pass-through-type-alias` | Disallows type aliases that only rename another type. |
+
+The rules use Oxlint's ESTree and lexical-scope APIs rather than a TypeScript type checker. They resolve same-file aliases but do not infer imported type definitions or cross-file call signatures.
+
+### Standard (`typescript/*`, in `recommended`)
+
+| Rule | Description |
+| --- | --- |
+| `typescript/no-deprecated` | Disallows using code marked `@deprecated`. Requires type-aware linting. |
+| `typescript/no-floating-promises` | Disallows floating Promises without handling. Requires type-aware linting. |
+
+### Opt-in (`deslop/canonical-class-names`, default off)
+
+Enforces canonical Tailwind CSS class spellings with `--fix` support (`mt-[16px]` → `mt-4`). Same source of truth as the Tailwind language server. Excluded from `recommended` because it requires a `cssPath` option — add it manually:
+
+```ts
+export default defineConfig({
+  jsPlugins: [deslopPlugin],
+  options: {
+    ...deslopConfigs.recommended.options,
+  },
+  rules: {
+    ...deslopConfigs.recommended.rules,
+    "deslop/canonical-class-names": ["warn", { cssPath: "./src/styles.css" }],
+  },
+});
+```
+
+Requires Tailwind CSS v4 (`tailwindcss` is an optional peer). Options: `cssPath` (required, absolute or relative to cwd), `rootFontSize` (default `16`), `attributes` (default `["class", "className"]`), `calleeFunctions` (default `["cn", "clsx", "cva", "twMerge", "tw", "classNames", "cx"]`). Only rewrites individual spellings — ordering/dedup belongs to the formatter. Strings with `${}` interpolations are skipped.
+
+## Credits
+
+- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "ai-deslop",
+  "version": "0.2.0",
+  "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
+  "type": "module",
+  "exports": "./src/index.ts",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "check": "oxlint src && tsc --noEmit",
+    "lint": "oxlint src",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.82.0",
+    "@tailwindcss/node": "^4.3.3",
+    "synckit": "^0.11.13"
+  },
+  "peerDependencies": {
+    "tailwindcss": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "oxlint": "1.82.0",
+    "typescript": "7.0.2"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maharshi365/deslop.git"
+  },
+  "homepage": "https://github.com/maharshi365/deslop#readme",
+  "bugs": {
+    "url": "https://github.com/maharshi365/deslop/issues"
+  },
+  "keywords": [
+    "oxlint",
+    "oxlint-plugin",
+    "eslint",
+    "ai-slop",
+    "code-quality",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,87 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noArrayFilterMapRule } from "./rules/no-array-filter-map.ts";
+import { noReduceAccumulatorCopyRule } from "./rules/no-reduce-accumulator-copy.ts";
+import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
+import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
+import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
+import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
+import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
+import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
+import { noReflectGetRule } from "./rules/no-reflect-get.ts";
+import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
+import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
+import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
+import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
+import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
+import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
+import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
+import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
+import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.ts";
+import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.ts";
+import { canonicalClassNames } from "./tailwind/rule.ts";
+
+/** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
+export const recommendedRules: Record<string, "error"> = {
+	"deslop/no-array-filter-map": "error",
+	"deslop/no-reduce-accumulator-copy": "error",
+	"deslop/no-chained-type-assertions": "error",
+	"deslop/no-conditional-empty-object-spread": "error",
+	"deslop/no-known-value-widening": "error",
+	"deslop/no-module-mocking": "error",
+	"deslop/no-object-parameters": "error",
+	"deslop/no-reflect-apply": "error",
+	"deslop/no-reflect-get": "error",
+	"deslop/no-runtime-typeof": "error",
+	"deslop/no-shape-in-symbol-names": "error",
+	"deslop/no-unknown-parameters": "error",
+	"deslop/no-unknown-returns": "error",
+	"deslop/no-unknown-type-aliases": "error",
+	"deslop/no-unsafe-dictionary-type": "error",
+	"deslop/no-widen-then-assert": "error",
+	"deslop/require-safety-comment-for-type-assertion": "error",
+	"deslop/no-call-only-assertions": "error",
+	"deslop/no-pass-through-type-alias": "error",
+	"typescript/no-deprecated": "error",
+	"typescript/no-floating-promises": "error",
+};
+
+/** ESLint flat-config style configs. `recommended` enables every `deslop/*` rule as `"error"` (except opt-in rules like `canonical-class-names`), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
+export const configs = {
+	recommended: {
+		name: "deslop/recommended",
+		options: { typeAware: true },
+		rules: recommendedRules,
+	},
+};
+
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const deslopPlugin = eslintCompatPlugin({
+	meta: { name: "deslop" },
+	rules: {
+		"no-array-filter-map": noArrayFilterMapRule,
+		"no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
+		"no-chained-type-assertions": noChainedTypeAssertionsRule,
+		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-runtime-typeof": noRuntimeTypeofRule,
+		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+		"no-call-only-assertions": noCallOnlyAssertionsRule,
+		"no-pass-through-type-alias": noPassThroughTypeAliasRule,
+		// Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
+		"canonical-class-names": canonicalClassNames,
+	},
+}) as ReturnType<typeof eslintCompatPlugin> & { configs: typeof configs };
+deslopPlugin.configs = configs;
+
+export default deslopPlugin;

package/src/rules/no-array-filter-map.ts

@@ -0,0 +1,28 @@
+import { defineRule } from "@oxlint/plugins";
+
+import { arrayMethodTarget, isKnownArrayExpression, unwrapArrayExpression } from "../shared/array-method.ts";
+
+/** Reject eager array filter/map pipelines; lazy iterator helpers remain allowed. */
+export const noArrayFilterMapRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
+    messages: {
+      arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics.",
+    },
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const outer = arrayMethodTarget(node.callee);
+        if (outer === null || (outer.name !== "map" && outer.name !== "filter")) return;
+        const innerCall = unwrapArrayExpression(outer.object);
+        if (innerCall.type !== "CallExpression") return;
+        const inner = arrayMethodTarget(innerCall.callee);
+        if (inner === null || inner.name !== (outer.name === "map" ? "filter" : "map")) return;
+        if (!isKnownArrayExpression(context.sourceCode, inner.object)) return;
+        context.report({ node, messageId: "arrayFilterMap", data: { first: inner.name, second: outer.name } });
+      },
+    };
+  },
+});

package/src/rules/no-call-only-assertions.ts

@@ -0,0 +1,94 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+// Tests whose every assertion is a "was it called" mock check verify orchestration, not behavior.
+// `toHaveBeenCalledWith` is allowed because it asserts on real data.
+
+const CALL_ONLY_MATCHERS = new Set(["toHaveBeenCalled", "toHaveBeenCalledTimes", "toHaveBeenCalledOnce"]);
+const TEST_NAMES = new Set(["it", "test"]);
+const MODIFIERS = new Set(["not", "resolves", "rejects"]);
+
+function rootIdentifierName(node: ESTree.Expression): string | undefined {
+	let current: ESTree.Expression = node;
+	while (true) {
+		if (current.type === "Identifier") return current.name;
+		if (current.type === "MemberExpression") {
+			current = current.object;
+		} else if (current.type === "CallExpression" || current.type === "TaggedTemplateExpression") {
+			current = current.type === "CallExpression" ? current.callee : current.tag;
+		} else {
+			return undefined;
+		}
+	}
+}
+
+function isTestCall(node: ESTree.CallExpression): boolean {
+	const name = rootIdentifierName(node.callee);
+	if (name === undefined || !TEST_NAMES.has(name)) return false;
+	const callback = node.arguments.at(-1);
+	return callback?.type === "FunctionExpression" || callback?.type === "ArrowFunctionExpression";
+}
+
+function matcherName(node: ESTree.CallExpression): string | undefined {
+	if (node.callee.type !== "MemberExpression" || node.callee.computed) return undefined;
+	if (node.callee.property.type !== "Identifier") return undefined;
+	let object: ESTree.Expression = node.callee.object;
+	while (
+		object.type === "MemberExpression" &&
+		!object.computed &&
+		object.property.type === "Identifier" &&
+		MODIFIERS.has(object.property.name)
+	) {
+		object = object.object;
+	}
+	const isExpectCall = object.type === "CallExpression" && rootIdentifierName(object.callee) === "expect";
+	return isExpectCall ? node.callee.property.name : undefined;
+}
+
+interface TestEntry {
+	node: ESTree.CallExpression;
+	total: number;
+	callOnly: number;
+}
+
+/** Tests must assert on behavior, not only that a mock was called. */
+export const noCallOnlyAssertionsRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Tests must assert on behavior, not only that a mock was called" },
+		messages: {
+			callOnlyAssertions:
+				"Every assertion in this test only checks that a mock was called. First check whether this is a valuable test; remove it if not. Otherwise, assert on returned values, state, or call arguments instead.",
+		},
+		schema: [],
+	},
+	createOnce(context) {
+		let tests: Array<TestEntry> = [];
+
+		return {
+			before() {
+				tests = [];
+			},
+			CallExpression(node) {
+				if (isTestCall(node)) {
+					tests.push({ node, total: 0, callOnly: 0 });
+					return;
+				}
+				const test = tests.at(-1);
+				if (!test) return;
+				const matcher = matcherName(node);
+				if (!matcher) return;
+				test.total += 1;
+				if (CALL_ONLY_MATCHERS.has(matcher)) test.callOnly += 1;
+			},
+			"CallExpression:exit"(node) {
+				const test = tests.at(-1);
+				if (test?.node !== node) return;
+				tests.pop();
+				if (test.total > 0 && test.total === test.callOnly) {
+					context.report({ messageId: "callOnlyAssertions", node: node.callee });
+				}
+			},
+		};
+	},
+});

package/src/rules/no-chained-type-assertions.ts

@@ -0,0 +1,77 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+type TypeAssertionExpression = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+function isTypeAssertionExpression(node: ESTree.Node): node is TypeAssertionExpression {
+  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+
+function unwrapParenthesizedExpression(expression: ESTree.Expression): ESTree.Expression {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isConstAssertion(node: TypeAssertionExpression): boolean {
+  const { typeAnnotation } = node;
+  return (
+    typeAnnotation.type === "TSTypeReference" &&
+    typeAnnotation.typeName.type === "Identifier" &&
+    typeAnnotation.typeName.name === "const"
+  );
+}
+
+function isOutermostAssertionInChain(node: TypeAssertionExpression): boolean {
+  let current: ESTree.Expression = node;
+  let parent = node.parent;
+
+  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+
+  return !isTypeAssertionExpression(parent) || parent.expression !== current;
+}
+
+function isForbiddenAssertionChain(node: TypeAssertionExpression): boolean {
+  let assertionCount = 0;
+  let hasNonConstAssertion = false;
+  let current: ESTree.Expression = node;
+
+  while (isTypeAssertionExpression(current)) {
+    assertionCount += 1;
+    hasNonConstAssertion ||= !isConstAssertion(current);
+    current = unwrapParenthesizedExpression(current.expression);
+  }
+
+  return assertionCount > 1 && hasNonConstAssertion;
+}
+
+/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
+export const noChainedTypeAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
+    },
+    messages: {
+      chained:
+        "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
+    },
+  },
+  createOnce(context) {
+    const checkTypeAssertion = (node: TypeAssertionExpression) => {
+      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
+      context.report({ node, messageId: "chained" });
+    };
+
+    return {
+      TSAsExpression: checkTypeAssertion,
+      TSTypeAssertion: checkTypeAssertion,
+    };
+  },
+});

package/src/rules/no-conditional-empty-object-spread.ts

@@ -0,0 +1,49 @@
+import { defineRule } from "@oxlint/plugins";
+import type { ESTree } from "@oxlint/plugins";
+
+function unwrapParentheses(node: ESTree.Expression): ESTree.Expression {
+  let current = node;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isEmptyObjectExpression(node: ESTree.Expression): boolean {
+  return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+
+function isConditionalEmptyObjectSpread(node: ESTree.Expression): boolean {
+  const conditional = unwrapParentheses(node);
+  return (
+    conditional.type === "ConditionalExpression" &&
+    (isEmptyObjectExpression(conditional.consequent) ||
+      isEmptyObjectExpression(conditional.alternate))
+  );
+}
+
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+export const noConditionalEmptyObjectSpreadRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow object spreads that conditionally spread an empty object to omit fields.",
+    },
+    messages: {
+      avoid:
+        "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
+    },
+  },
+  createOnce(context) {
+    return {
+      SpreadElement(node) {
+        if (node.parent.type !== "ObjectExpression") return;
+
+        if (isConditionalEmptyObjectSpread(node.argument)) {
+          context.report({ node, messageId: "avoid" });
+        }
+      },
+    };
+  },
+});