@timmo001/oxlint-rules 0.1.0

package/dist/upstream/effect.js

@@ -0,0 +1,59 @@
+// vendor/anti-slop/src/effect/index.ts
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
+import { defineRule } from "@oxlint/plugins";
+var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+function isProjectLocalImport(source) {
+  return source.startsWith("./") || source.startsWith("../");
+}
+function getImportedName(specifier) {
+  if (specifier.imported.type === "Identifier")
+    return specifier.imported.name;
+  return specifier.imported.value;
+}
+var 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 }
+          });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/index.ts
+var antiSlopEffectPlugin = eslintCompatPlugin({
+  meta: { name: "anti-slop-effect" },
+  rules: {
+    "no-service-constructor-imports": noServiceConstructorImportsRule
+  }
+});
+var effect_default = antiSlopEffectPlugin;
+export {
+  effect_default as default
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@timmo001/oxlint-rules",
+  "version": "0.1.0",
+  "description": "Shared Oxlint plugins and configs with optional Effect rules.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/timmo001/oxlint-rules.git"
+  },
+  "bin": {
+    "oxlint-rules": "./dist/cli.js"
+  },
+  "exports": {
+    "./upstream/anti-slop": "./dist/upstream/anti-slop.js",
+    "./upstream/effect": "./dist/upstream/effect.js",
+    "./effect": "./dist/effect/index.js",
+    "./configs/recommended": "./dist/configs/recommended.js",
+    "./configs/effect": "./dist/configs/effect.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "vendor/anti-slop/src",
+    "vendor/anti-slop/LICENSE",
+    "!vendor/anti-slop/src/**/*.test.ts",
+    "skills",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "check": "bun run build && bun run test && bun run lint && bun run typecheck && bun run format:check && bun run skills:validate",
+    "format": "prettier --write \"{src,scripts}/**/*.ts\" \"skills/**/*.{md,mjs}\" \"*.md\" \"*.json\"",
+    "format:check": "prettier --check \"{src,scripts}/**/*.ts\" \"skills/**/*.{md,mjs}\" \"*.md\" \"*.json\"",
+    "lint": "oxlint src scripts",
+    "skills:validate": "bunx skills-ref validate skills/install-timmo-oxlint-rules && bunx skills-ref validate skills/add-oxlint-rule",
+    "test": "node --experimental-strip-types src/effect/rules/no-try-catch-in-effect-generators.test.ts && bun test src/install/copy.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@oxlint/plugins": "1.81.0",
+    "oxlint": "1.81.0"
+  },
+  "devDependencies": {
+    "@oxlint/plugins": "1.81.0",
+    "@types/bun": "^1.3.14",
+    "oxlint": "1.81.0",
+    "prettier": "^3.9.5",
+    "skills-ref": "0.1.5",
+    "typescript": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/add-oxlint-rule/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: add-oxlint-rule
+description: >-
+  Create or revise a centrally maintained rule in @timmo001/oxlint-rules. Use
+  for requests to add an Oxlint anti-slop rule, change an existing central
+  rule, or promote a repository-specific lint preference into the shared
+  package.
+---
+
+# Add An Oxlint Rule
+
+1. Treat the current repository as fixture context, not automatically as the
+   central package checkout.
+2. Search available writable checkouts by their Git remote for
+   `timmo001/oxlint-rules`. If none exists, ask where the user wants to clone or
+   fork it. Do not assume the user can write to the upstream account.
+3. Read the central repository guidance, relevant plugin registration, config,
+   nearby rules, tests, and README rule list.
+4. Define the narrow syntax contract. Add at least one failing fixture and one
+   valid fixture before implementing the rule.
+5. Put generic upstream-independent rules under the appropriate locally owned
+   plugin. Never modify `vendor/anti-slop`; propose an upstream contribution
+   separately when Dylan Mulroy's plugin should own the behaviour.
+6. Register the rule in its plugin and matching config, then update the README
+   rule list and behaviour description.
+7. Run `mise run check`, `mise run build`, `npm pack --dry-run`, and
+   `bunx jsr@0.14.3 publish --dry-run` in the central checkout.
+
+Report the fixture contract, registration and docs changed, checks, and any
+consumer rollout left for a separate stage. Do not publish or assume a local
+machine path.

package/skills/install-timmo-oxlint-rules/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: install-timmo-oxlint-rules
+description: >-
+  Install or copy @timmo001/oxlint-rules into a JavaScript or TypeScript
+  repository. Use when adding the shared anti-slop Oxlint config, enabling its
+  Effect rules, or replacing a local anti-slop copy.
+---
+
+# Install Timmo Oxlint Rules
+
+1. Ask one structured question before changing files: `Package (Recommended)`
+   or `Copy rules`.
+2. Inspect the target's manifests, lockfiles, Oxlint config, repository
+   instructions, and normal checks. Use the current working directory unless
+   the user names another target.
+3. Preserve existing ignores, overrides, plugins, and repository-owned rules.
+   Confirm `oxlint` and `@oxlint/plugins` use the same exact version supported
+   by the selected package version.
+
+## Package
+
+1. Ask whether to use npmjs.org or JSR.
+2. Detect Bun, npm, pnpm, or Yarn from the target's package manager declaration
+   and lockfile. Add an exact development dependency through that package
+   manager.
+3. Extend `@timmo001/oxlint-rules/configs/recommended`. Use `/configs/effect`
+   instead only when `effect` is a direct dependency or the user explicitly
+   requests it.
+4. Keep dependency and config edits visible. Do not delegate them to a script.
+
+## Copy rules
+
+1. Ask for a repository-relative destination. Do not assume a personal
+   filesystem layout.
+2. If the destination exists, compare it with the proposed source and explain
+   meaningful differences before asking whether replacement is intended.
+3. Run `node scripts/copy.mjs <bun|npm|pnpm|yarn> <destination>`. Add `--force`
+   only after explicit replacement approval.
+4. Register the three entry points printed by the command as `anti-slop`,
+   `anti-slop-effect`, and `timmo-effect`. Enable `timmo-effect` only for direct
+   Effect use or an explicit request.
+
+Run the target repository's normal lint, typecheck, tests, and build. Report
+package-manager changes, preserved local configuration, enabled rule groups,
+and checks.

package/skills/install-timmo-oxlint-rules/scripts/copy.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+
+const [runner, ...copyArguments] = process.argv.slice(2);
+const packageName = "@timmo001/oxlint-rules";
+const commands = {
+  bun: ["bunx", packageName, "copy", ...copyArguments],
+  npm: [
+    "npm",
+    "exec",
+    "--yes",
+    `--package=${packageName}`,
+    "--",
+    "oxlint-rules",
+    "copy",
+    ...copyArguments,
+  ],
+  pnpm: ["pnpm", "dlx", packageName, "copy", ...copyArguments],
+  yarn: ["yarn", "dlx", packageName, "copy", ...copyArguments],
+};
+
+const command = commands[runner];
+if (!command) {
+  console.error("Usage: copy.mjs <bun|npm|pnpm|yarn> <destination> [--force]");
+  process.exit(1);
+}
+
+const result = spawnSync(command[0], command.slice(1), { stdio: "inherit" });
+if (result.error) throw result.error;
+process.exit(result.status ?? 1);

package/src/cli.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+
+import { copyRules, DEFAULT_COPY_DESTINATION } from "./install/copy.ts";
+
+function usage() {
+  return "Usage: oxlint-rules copy [destination] [--force]";
+}
+
+const [command, ...arguments_] = process.argv.slice(2);
+if (command === "--help" || command === "-h") {
+  console.log(usage());
+} else if (command !== "copy") {
+  console.error(usage());
+  process.exitCode = 1;
+} else {
+  const force = arguments_.includes("--force");
+  const positional = arguments_.filter((argument) => argument !== "--force");
+  if (positional.length > 1) {
+    console.error(usage());
+    process.exitCode = 1;
+  } else {
+    try {
+      const destination = resolve(positional[0] ?? DEFAULT_COPY_DESTINATION);
+      const entries = await copyRules(destination, { force });
+      console.log("Copied Oxlint plugins:");
+      console.log(`  anti-slop: ${entries.antiSlop}`);
+      console.log(`  anti-slop-effect: ${entries.antiSlopEffect}`);
+      console.log(`  timmo-effect: ${entries.timmoEffect}`);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    }
+  }
+}

package/src/configs/effect.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from "oxlint";
+
+import recommended from "./recommended.ts";
+
+const effect = defineConfig({
+  extends: [recommended],
+  jsPlugins: [
+    {
+      name: "anti-slop-effect",
+      specifier: "@timmo001/oxlint-rules/upstream/effect",
+    },
+    { name: "timmo-effect", specifier: "@timmo001/oxlint-rules/effect" },
+  ],
+  rules: {
+    "anti-slop-effect/no-service-constructor-imports": "error",
+    "timmo-effect/no-try-catch-in-effect-generators": "error",
+  },
+});
+
+export default effect;

package/src/configs/recommended.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from "oxlint";
+
+const recommended = defineConfig({
+  jsPlugins: [
+    {
+      name: "anti-slop",
+      specifier: "@timmo001/oxlint-rules/upstream/anti-slop",
+    },
+  ],
+  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",
+  },
+});
+
+export default recommended;

package/src/effect/index.ts

@@ -0,0 +1,12 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { noTryCatchInEffectGeneratorsRule } from "./rules/no-try-catch-in-effect-generators.ts";
+
+const timmoEffectPlugin = eslintCompatPlugin({
+  meta: { name: "timmo-effect" },
+  rules: {
+    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule,
+  },
+});
+
+export default timmoEffectPlugin;

package/src/effect/rules/no-try-catch-in-effect-generators.ts

@@ -0,0 +1,140 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
+
+type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
+
+function resolveVariable(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+): Variable | null {
+  let scope: Scope | null = sourceCode.getScope(identifier);
+  while (scope) {
+    const variable = scope.set.get(identifier.name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function nearestEnclosingFunction(node: ESTree.Node): FunctionNode | null {
+  let current: ESTree.Node | null = node.parent;
+  while (current) {
+    if (
+      current.type === "FunctionDeclaration" ||
+      current.type === "FunctionExpression" ||
+      current.type === "ArrowFunctionExpression"
+    ) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+function staticMemberName(node: ESTree.Expression): string | null {
+  if (node.type !== "MemberExpression" || node.computed) return null;
+  return node.property.type === "Identifier" ? node.property.name : null;
+}
+
+function isEffectImport(
+  sourceCode: SourceCode,
+  identifier: ESTree.IdentifierReference,
+  namespace: boolean,
+): boolean {
+  const variable = resolveVariable(sourceCode, identifier);
+  return (
+    variable?.defs.some((definition) => {
+      if (
+        definition.type !== "ImportBinding" ||
+        definition.parent?.type !== "ImportDeclaration" ||
+        definition.parent.source.value !== "effect"
+      ) {
+        return false;
+      }
+      if (namespace) return definition.node.type === "ImportNamespaceSpecifier";
+      if (definition.node.type !== "ImportSpecifier") return false;
+      const imported = definition.node.imported;
+      return (
+        (imported.type === "Identifier" ? imported.name : imported.value) ===
+        "Effect"
+      );
+    }) ?? false
+  );
+}
+
+function isEffectMethod(
+  sourceCode: SourceCode,
+  node: ESTree.Expression,
+  method: "fn" | "gen",
+): boolean {
+  if (staticMemberName(node) !== method || node.type !== "MemberExpression") {
+    return false;
+  }
+  const object = node.object;
+  if (object.type === "Identifier") {
+    return isEffectImport(sourceCode, object, false);
+  }
+  if (
+    staticMemberName(object) !== "Effect" ||
+    object.type !== "MemberExpression" ||
+    object.object.type !== "Identifier"
+  ) {
+    return false;
+  }
+  return isEffectImport(sourceCode, object.object, true);
+}
+
+function isDirectArgument(
+  owner: FunctionNode,
+  call: ESTree.CallExpression,
+): boolean {
+  return call.arguments.some((argument) => argument === owner);
+}
+
+function isRecognisedEffectGenerator(
+  sourceCode: SourceCode,
+  owner: FunctionNode,
+): boolean {
+  const parent = owner.parent;
+  if (parent.type !== "CallExpression" || !isDirectArgument(owner, parent)) {
+    return false;
+  }
+  if (isEffectMethod(sourceCode, parent.callee, "gen")) return true;
+
+  const factoryCall = parent.callee;
+  return (
+    factoryCall.type === "CallExpression" &&
+    isEffectMethod(sourceCode, factoryCall.callee, "fn")
+  );
+}
+
+/** Keep expected failures in the Effect error channel inside Effect generators. */
+export const noTryCatchInEffectGeneratorsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow synchronous try/catch owned by recognised Effect generator callbacks.",
+    },
+    messages: {
+      useEffectErrorChannel:
+        "Keep expected failures in the Effect error channel. Use Effect.try for synchronous throwing work, Effect.tryPromise for asynchronous throwing work, Effect-returning schema APIs for decoding, and Effect recovery combinators for recovery.",
+    },
+  },
+  create(context) {
+    return {
+      TryStatement(node) {
+        if (!node.handler) return;
+        const owner = nearestEnclosingFunction(node);
+        if (
+          !owner?.generator ||
+          !isRecognisedEffectGenerator(context.sourceCode, owner)
+        ) {
+          return;
+        }
+        context.report({ node, messageId: "useEffectErrorChannel" });
+      },
+    };
+  },
+});

package/src/install/copy.ts

@@ -0,0 +1,77 @@
+import { cp, mkdir, readdir, rm } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const DEFAULT_COPY_DESTINATION = "tools/oxlint/timmo-rules";
+
+export interface CopyRulesOptions {
+  readonly force?: boolean;
+  readonly sourceRoot?: string;
+}
+
+export interface CopiedRuleEntryPoints {
+  readonly antiSlop: string;
+  readonly antiSlopEffect: string;
+  readonly timmoEffect: string;
+}
+
+function packageRoot() {
+  const current = dirname(fileURLToPath(import.meta.url));
+  return current.endsWith(join("src", "install"))
+    ? resolve(current, "../..")
+    : resolve(current, "..");
+}
+
+async function copyTree(source: string, destination: string) {
+  await cp(source, destination, {
+    recursive: true,
+    filter: (path) =>
+      !path.endsWith(".test.ts") && !path.includes(`${join("", ".git")}`),
+  });
+}
+
+export async function copyRules(
+  destination: string,
+  options: CopyRulesOptions = {},
+): Promise<CopiedRuleEntryPoints> {
+  const target = resolve(destination);
+  const entries = await readdir(dirname(target), { withFileTypes: true }).catch(
+    () => [],
+  );
+  if (entries.some((entry) => entry.name === target.split(/[\\/]/u).at(-1))) {
+    if (!options.force) {
+      throw new Error(
+        `Destination already exists: ${target}. Pass --force to replace it.`,
+      );
+    }
+    await rm(target, { force: true, recursive: true });
+  }
+
+  const root = options.sourceRoot ?? packageRoot();
+  await mkdir(join(target, "upstream"), { recursive: true });
+  await copyTree(
+    join(root, "vendor/anti-slop/src"),
+    join(target, "upstream/anti-slop"),
+  );
+  await cp(
+    join(root, "vendor/anti-slop/LICENSE"),
+    join(target, "upstream/anti-slop/LICENSE"),
+  );
+  await rm(join(target, "upstream/anti-slop/effect"), {
+    force: true,
+    recursive: true,
+  });
+  await copyTree(
+    join(root, "vendor/anti-slop/src/effect"),
+    join(target, "upstream/effect"),
+  );
+  await copyTree(join(root, "src/effect"), join(target, "effect"));
+
+  const displayRoot = relative(process.cwd(), target) || ".";
+  const entryPoint = (path: string) => `./${path.split(sep).join("/")}`;
+  return {
+    antiSlop: entryPoint(join(displayRoot, "upstream/anti-slop/index.ts")),
+    antiSlopEffect: entryPoint(join(displayRoot, "upstream/effect/index.ts")),
+    timmoEffect: entryPoint(join(displayRoot, "effect/index.ts")),
+  };
+}

package/src/jsr/effect-config.ts

@@ -0,0 +1,7 @@
+import type { OxlintConfig } from "oxlint";
+
+import bundledConfig from "../../dist/configs/effect.js";
+
+const config: OxlintConfig = bundledConfig;
+
+export default config;

package/src/jsr/effect.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@oxlint/plugins";
+
+import bundledPlugin from "../../dist/effect/index.js";
+
+const plugin: Plugin = bundledPlugin;
+
+export default plugin;

package/src/jsr/recommended.ts

@@ -0,0 +1,7 @@
+import type { OxlintConfig } from "oxlint";
+
+import bundledConfig from "../../dist/configs/recommended.js";
+
+const config: OxlintConfig = bundledConfig;
+
+export default config;

package/src/jsr/upstream-anti-slop.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@oxlint/plugins";
+
+import bundledPlugin from "../../dist/upstream/anti-slop.js";
+
+const plugin: Plugin = bundledPlugin;
+
+export default plugin;

package/src/jsr/upstream-effect.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@oxlint/plugins";
+
+import bundledPlugin from "../../dist/upstream/effect.js";
+
+const plugin: Plugin = bundledPlugin;
+
+export default plugin;

package/src/upstream/anti-slop.ts

@@ -0,0 +1 @@
+export { default } from "../../vendor/anti-slop/src/index.ts";

package/src/upstream/effect.ts

@@ -0,0 +1 @@
+export { default } from "../../vendor/anti-slop/src/effect/index.ts";

package/vendor/anti-slop/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.