@kamaal111/oxlint-plugin-anti-slop 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dillon Mulroy
+
+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,264 @@
+# anti-slop
+
+[![skills.sh](https://skills.sh/b/dmmulroy/anti-slop)](https://skills.sh/dmmulroy/anti-slop)
+
+Opinionated Oxlint rules that reject low-evidence and low-signal TypeScript and JavaScript patterns.
+
+This project is meant to be vendored, not treated as a fixed npm dependency. Copy the rules into your repository, read them, and change them to match your team's standards. The bundled agent skill handles the initial copy and configuration; after that, the vendored files are yours to maintain and make your own.
+
+## Install with an agent skill
+
+```bash
+npx skills add dmmulroy/anti-slop --skill install-anti-slop
+```
+
+Then ask your coding agent to install or configure anti-slop in the current repository. The skill copies the plugin, installs current Oxlint dependencies, merges the plugin into the existing lint configuration, enables every generic rule, and validates the result. In repositories that depend on Effect, it also enables the opt-in Effect rule group.
+
+To inspect available skills first:
+
+```bash
+npx skills add dmmulroy/anti-slop --list
+```
+
+## Manual local installation
+
+Copy `src/` into the target repository, for example at `tools/oxlint/anti-slop/`, and install matching current versions of `oxlint` and `@oxlint/plugins`.
+
+Register the copied entry point in `oxlint.config.ts`:
+
+```ts
+import { defineConfig } from "oxlint";
+
+export default defineConfig({
+  ignorePatterns: [
+    ".agent/**",
+    ".agents/**",
+    ".claude/**",
+    ".codex/**",
+    ".continue/**",
+    ".cursor/**",
+    ".gemini/**",
+    ".opencode/**",
+    ".pi/**",
+    ".roo/**",
+    ".windsurf/**",
+    "tools/oxlint/anti-slop/**",
+  ],
+  jsPlugins: [
+    { name: "anti-slop", specifier: "./tools/oxlint/anti-slop/index.ts" },
+  ],
+  rules: {
+    "anti-slop/no-chained-type-assertions": "error",
+    "anti-slop/no-conditional-empty-object-spread": "error",
+    "anti-slop/no-known-value-widening": "error",
+    "anti-slop/no-module-mocking": "error",
+    "anti-slop/no-object-parameters": "error",
+    "anti-slop/no-reflect-apply": "error",
+    "anti-slop/no-reflect-get": "error",
+    "anti-slop/no-runtime-typeof": "error",
+    "anti-slop/no-shape-in-symbol-names": "error",
+    "anti-slop/no-unknown-parameters": "error",
+    "anti-slop/no-unknown-returns": "error",
+    "anti-slop/no-unknown-type-aliases": "error",
+    "anti-slop/no-unsafe-dictionary-type": "error",
+    "anti-slop/no-widen-then-assert": "error",
+    "anti-slop/require-safety-comment-for-type-assertion": "error"
+  }
+});
+```
+
+The same `ignorePatterns`, `jsPlugins`, and rules work under `lint` in a Vite+ config. Merge the ignore patterns into Vite+'s `fmt.ignorePatterns` as well so `vp check` does not reformat installed agent assets or the vendored plugin. Preserve existing ignores and add any other project-local agent tooling directories detected in the repository; do not broadly ignore every dot-directory.
+
+### Optional Effect rules
+
+Effect-specific rules live in a separate plugin so projects that do not use Effect do not inherit Effect architecture policy. Register the Effect entry point only in repositories that use Effect:
+
+```ts
+export default defineConfig({
+  jsPlugins: [
+    { name: "anti-slop", specifier: "./tools/oxlint/anti-slop/index.ts" },
+    {
+      name: "anti-slop-effect",
+      specifier: "./tools/oxlint/anti-slop/effect/index.ts"
+    }
+  ],
+  rules: {
+    "anti-slop-effect/no-service-constructor-imports": "error"
+  }
+});
+```
+
+## Rules
+
+### Generic rules
+
+- `no-chained-type-assertions` — rejects nested type assertions that fabricate evidence.
+- `no-conditional-empty-object-spread` — rejects conditional spreads that use `{}` to omit fields.
+- `no-known-value-widening` — rejects explicit broad target types that discard known value evidence.
+- `no-module-mocking` — rejects Vitest and Jest module mocks in favor of real dependency seams.
+- `no-object-parameters` — rejects the broad `object` type on function inputs.
+- `no-reflect-apply` — rejects `Reflect.apply` in favor of typed function calls.
+- `no-reflect-get` — rejects `Reflect.get` in favor of typed property access or boundary parsing.
+- `no-runtime-typeof` — requires boundary parsing instead of ad hoc `typeof` narrowing.
+- `no-shape-in-symbol-names` — rejects `shape` in symbol names.
+- `no-unknown-parameters` — rejects `unknown` inputs except the explicit `cause` convention.
+- `no-unknown-returns` — rejects function contracts that return `unknown` or `Promise<unknown>`.
+- `no-unknown-type-aliases` — rejects aliases that merely conceal `unknown`.
+- `no-unsafe-dictionary-type` — rejects dictionary value contracts based on `unknown`, `any`, `object`, `{}`, and semantic equivalents.
+- `no-widen-then-assert` — rejects local flows that widen known values and later assert them back.
+- `require-safety-comment-for-type-assertion` — requires each non-const assertion to document its checked invariant.
+
+### Effect rules
+
+- `no-service-constructor-imports` — rejects relative project imports of exported `make<CapabilityName>` constructors outside `*.test.*` and `*.spec.*` files. Runtime callers should import the owning Layer and yield the contextual service instead. Package imports and static constructors such as `WorkspaceName.make` are outside the rule.
+
+## Violation examples
+
+Each snippet below is rejected by the named rule.
+
+### `no-chained-type-assertions`
+
+```ts
+const user = input as object as User;
+```
+
+### `no-conditional-empty-object-spread`
+
+```ts
+const options = {
+  ...(timeout !== undefined ? { timeout } : {}),
+};
+```
+
+### `no-known-value-widening`
+
+```ts
+const handlers: Record<string, Handler> = {
+  start: startHandler,
+};
+```
+
+This discards the known `start` key. Preserve inference or use `satisfies Record<string, Handler>` instead.
+
+### `no-module-mocking`
+
+```ts
+vi.mock("./user-store");
+```
+
+### `no-object-parameters`
+
+```ts
+function save(value: object) {}
+```
+
+### `no-reflect-apply`
+
+```ts
+const value = Reflect.apply(operation, owner, args);
+```
+
+### `no-reflect-get`
+
+```ts
+const value = Reflect.get(owner, key);
+```
+
+### `no-runtime-typeof`
+
+```ts
+if (typeof input === "string") {
+  useName(input);
+}
+```
+
+Schema-free projects can permit `typeof` checks directly inside type predicate and
+assertion functions while continuing to reject ad hoc checks elsewhere:
+
+```json
+{
+  "anti-slop/no-runtime-typeof": [
+    "error",
+    { "allowInTypeGuards": true }
+  ]
+}
+```
+
+The option defaults to `false`.
+
+### `no-shape-in-symbol-names`
+
+```ts
+interface UserShape {
+  id: string;
+}
+```
+
+### Effect: `no-service-constructor-imports`
+
+```ts
+import { makeIssueService } from "./issue-service.ts";
+```
+
+Import the owning Layer and yield `IssueService` instead. Focused `*.test.*` and `*.spec.*` files may import the constructor directly.
+
+### `no-unknown-parameters`
+
+```ts
+function handle(input: unknown) {}
+```
+
+### `no-unknown-returns`
+
+```ts
+function loadUser(): unknown {
+  return input;
+}
+```
+
+### `no-unknown-type-aliases`
+
+```ts
+type ExternalValue = unknown;
+```
+
+### `no-unsafe-dictionary-type`
+
+```ts
+type Metadata = Record<string, unknown>;
+type OtherMetadata = { [key: string]: object };
+```
+
+### `no-widen-then-assert`
+
+```ts
+const loaded: User = loadUser();
+const stored: unknown = loaded;
+const user = stored as User;
+```
+
+### `require-safety-comment-for-type-assertion`
+
+```ts
+const userId = value as UserId;
+```
+
+Add a specific justification immediately before a necessary assertion:
+
+```ts
+// SAFETY: parseUserId validated the identifier before branding it.
+const userId = value as UserId;
+```
+
+## Development
+
+```bash
+pnpm install
+pnpm check
+```
+
+`src/` is canonical. After changing production source, run `pnpm sync:skill-assets`; CI checks that the skill's bundled copy remains identical.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@kamaal111/oxlint-plugin-anti-slop",
+  "version": "0.0.1",
+  "description": "Opinionated Oxlint rules that reject low-evidence TypeScript and JavaScript patterns.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kamaal111/anti-slop.git"
+  },
+  "type": "module",
+  "exports": "./src/index.ts",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "check": "pnpm lint && pnpm test && pnpm typecheck && pnpm check:skill-assets",
+    "lint": "oxlint src",
+    "test": "tsx src/rules/no-conditional-empty-object-spread.test.ts && tsx src/rules/no-unsafe-dictionary-type.test.ts && tsx src/rules/no-known-value-widening.test.ts && tsx src/rules/no-object-parameters.test.ts && tsx src/rules/no-runtime-typeof.test.ts && tsx src/rules/no-unknown-returns.test.ts && tsx src/rules/no-unknown-type-aliases.test.ts && tsx src/rules/no-widen-then-assert.test.ts && tsx src/rules/no-reflect-get.test.ts && tsx src/rules/no-reflect-apply.test.ts && tsx src/rules/no-module-mocking.test.ts && tsx src/rules/require-safety-comment-for-type-assertion.test.ts && tsx src/effect/rules/no-service-constructor-imports.test.ts",
+    "typecheck": "tsc --noEmit",
+    "release": "sh scripts/publish.sh",
+    "sync:skill-assets": "node scripts/sync-skill-assets.mjs",
+    "check:skill-assets": "node scripts/sync-skill-assets.mjs --check"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.78.0"
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "oxlint": "1.78.0",
+    "tsx": "4.23.12",
+    "typescript": "7.0.2"
+  },
+  "packageManager": "pnpm@10.33.0",
+  "license": "MIT"
+}

package/src/effect/index.ts

@@ -0,0 +1,13 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.ts";
+
+/** Opt-in Oxlint rules for Effect service and Layer architecture. */
+const antiSlopEffectPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop-effect" },
+	rules: {
+		"no-service-constructor-imports": noServiceConstructorImportsRule,
+	},
+});
+
+export default antiSlopEffectPlugin;

package/src/effect/rules/no-service-constructor-imports.test.ts

@@ -0,0 +1,56 @@
+import { RuleTester } from "oxlint/plugins-dev";
+
+import { noServiceConstructorImportsRule } from "./no-service-constructor-imports.ts";
+
+new RuleTester().run(
+	"no-service-constructor-imports",
+	noServiceConstructorImportsRule,
+	{
+		valid: [
+			{
+				filename: "src/issue-service.test.ts",
+				code: 'import { makeIssueService } from "./issue-service.ts";',
+			},
+			{
+				filename: "src/issue-service.spec.tsx",
+				code: 'import { makeIssueService } from "../issue-service.ts";',
+			},
+			{
+				filename: "src/runtime.ts",
+				code: 'import { makeExecutionMemo } from "alchemy/Runtime/ExecutionMemo";',
+			},
+			{
+				filename: "src/runtime.ts",
+				code: 'import { issueServiceLayer } from "./issue-service.ts";\nWorkspaceName.make("name");',
+			},
+			{
+				filename: "src/runtime.ts",
+				code: 'import { makeissueService } from "./issue-service.ts";',
+			},
+		],
+		invalid: [
+			{
+				filename: "src/runtime.ts",
+				code: 'import { makeIssueService } from "./issue-service.ts";',
+				errors: [
+					{
+						messageId: "serviceConstructorImport",
+						data: { name: "makeIssueService" },
+					},
+				],
+				output: null,
+			},
+			{
+				filename: "src/runtime.ts",
+				code: 'import { makeIssueService as createIssueService } from "../issue-service.ts";',
+				errors: [
+					{
+						messageId: "serviceConstructorImport",
+						data: { name: "makeIssueService" },
+					},
+				],
+				output: null,
+			},
+		],
+	},
+);

package/src/effect/rules/no-service-constructor-imports.ts

@@ -0,0 +1,52 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+const SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+
+function isProjectLocalImport(source: string): boolean {
+	return source.startsWith("./") || source.startsWith("../");
+}
+
+function getImportedName(specifier: ESTree.ImportSpecifier): string {
+	if (specifier.imported.type === "Identifier") return specifier.imported.name;
+	return specifier.imported.value;
+}
+
+/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
+export const noServiceConstructorImportsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description:
+				"Disallow project-local make<CapabilityName> imports outside test and spec files.",
+		},
+		messages: {
+			serviceConstructorImport:
+				'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
+		},
+	},
+	create(context) {
+		const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+
+		return {
+			ImportDeclaration(node) {
+				if (isTestFile || !isProjectLocalImport(node.source.value)) return;
+
+				for (const specifier of node.specifiers) {
+					if (specifier.type !== "ImportSpecifier") continue;
+
+					const importedName = getImportedName(specifier);
+					if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) continue;
+
+					context.report({
+						node: specifier,
+						messageId: "serviceConstructorImport",
+						data: { name: importedName },
+					});
+				}
+			},
+		};
+	},
+});

package/src/index.ts

@@ -0,0 +1,41 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+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";
+
+/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
+const antiSlopPlugin = eslintCompatPlugin({
+	meta: { name: "anti-slop" },
+	rules: {
+		"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-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+		"no-unknown-parameters": noUnknownParametersRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-widen-then-assert": noWidenThenAssertRule,
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+	},
+});
+
+export default antiSlopPlugin;

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.test.ts

@@ -0,0 +1,32 @@
+import { RuleTester } from "oxlint/plugins-dev";
+
+import { noConditionalEmptyObjectSpreadRule } from "./no-conditional-empty-object-spread.ts";
+
+const tester = new RuleTester({ languageOptions: { parserOptions: { lang: "ts" } } });
+const error = { messageId: "avoid" };
+
+if (noConditionalEmptyObjectSpreadRule.meta?.fixable !== undefined) {
+  throw new Error("The rule must not offer an unsafe semantics-changing fix.");
+}
+
+tester.run(
+  "anti-slop/no-conditional-empty-object-spread",
+  noConditionalEmptyObjectSpreadRule,
+  {
+    valid: [
+      "const result = { value };",
+      "const result = { ...values };",
+      "const result = condition ? { value } : {};",
+    ],
+    invalid: [
+      {
+        code: "const result = { ...(value !== undefined ? { value } : {}) };",
+        errors: [error],
+      },
+      {
+        code: "const result = { ...(condition ? {} : { value }) };",
+        errors: [error],
+      },
+    ],
+  },
+);

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" });
+        }
+      },
+    };
+  },
+});