ai-deslop 0.4.2 → 0.4.4

package/README.md

@@ -50,19 +50,24 @@ The recommended config enables type-aware linting for `typescript/no-deprecated`
 | `no-widen-then-assert` | Recommended | Rejects widening known evidence before narrowing assertions. |
 | `require-safety-comment-for-type-assertion` | Recommended | Requires an invariant justification for non-const assertions. |
 | `no-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
+| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
 | `no-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
+| [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Opt-in | Reports all-caps constants with the same static value in different files. |
 | [`no-duplicate-types`](docs/no-duplicate-types.md) | Opt-in | Reports exact duplicate object contracts. No fixer. |
 | [`canonical-class-names`](docs/tailwind.md) | Opt-in | Fixes non-canonical Tailwind CSS v4 class spellings. |
 
 | Standard rule | Status | Description |
 | --- | --- | --- |
 | `typescript/no-deprecated` | Recommended | Disallows using code marked `@deprecated`. Requires type-aware linting. |
+| `typescript/no-require-imports` | Recommended | Disallows CommonJS `require()` imports. |
 | `typescript/no-floating-promises` | Recommended | Disallows floating promises. Requires type-aware linting. |
+| `no-unreachable` | Recommended | Disallows unreachable code. |
 
 ## Guides
 
 | Guide | Contents |
 | --- | --- |
+| [No duplicate consts](docs/no-duplicate-consts.md) | Configuration and exact static-value comparison behavior. |
 | [No duplicate types](docs/no-duplicate-types.md) | Exact comparison behavior, worker scope, complete TypeScript/JSON examples, and every supported option. |
 | [Tailwind canonical class names](docs/tailwind.md) | Tailwind v4 setup, complete TypeScript/JSON examples, and every supported option. |
 

package/dist/index.js

@@ -17,8 +17,10 @@ import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.js
 import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.js";
 import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.js";
 import { noCallOnlyAssertionsRule } from "./rules/no-call-only-assertions.js";
+import { noPoorSubstringTestsRule } from "./rules/no-poor-substring-tests.js";
 import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.js";
 import { noDuplicateTypesRule } from "./rules/no-duplicate-types.js";
+import { noDuplicateConstsRule } from "./rules/no-duplicate-consts.js";
 import { canonicalClassNames } from "./tailwind/rule.js";
 /** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
 export const recommendedRules = {
@@ -40,9 +42,12 @@ export const recommendedRules = {
     "deslop/no-widen-then-assert": "error",
     "deslop/require-safety-comment-for-type-assertion": "error",
     "deslop/no-call-only-assertions": "error",
+    "deslop/no-poor-substring-tests": "error",
     "deslop/no-pass-through-type-alias": "error",
     "typescript/no-deprecated": "error",
+    "typescript/no-require-imports": "error",
     "typescript/no-floating-promises": "error",
+    "no-unreachable": "error",
 };
 /** ESLint flat-config style configs. `recommended` enables every recommended `deslop/*` rule as `"error"` (excluding opt-in rules), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
 export const configs = {
@@ -74,8 +79,11 @@ const deslopPlugin = eslintCompatPlugin({
         "no-widen-then-assert": noWidenThenAssertRule,
         "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
         "no-call-only-assertions": noCallOnlyAssertionsRule,
+        "no-poor-substring-tests": noPoorSubstringTestsRule,
+        "no-constant-substring-tests": noPoorSubstringTestsRule,
         "no-pass-through-type-alias": noPassThroughTypeAliasRule,
         "no-duplicate-types": noDuplicateTypesRule,
+        "no-duplicate-consts": noDuplicateConstsRule,
         // Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
         "canonical-class-names": canonicalClassNames,
     },

package/dist/rules/no-duplicate-consts.d.ts

@@ -0,0 +1,2 @@
+/** Report static all-caps constants duplicated by name and value in another file. */
+export declare const noDuplicateConstsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-duplicate-consts.js

@@ -0,0 +1,68 @@
+import { defineRule } from "@oxlint/plugins";
+function staticValue(node) {
+    if (node.type === "Literal") {
+        return JSON.stringify(["literal", typeof node.value, String(node.value)]);
+    }
+    if (node.type === "TemplateLiteral") {
+        return node.expressions.length === 0 ? JSON.stringify(["literal", "string", node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? ""]) : null;
+    }
+    if (node.type === "UnaryExpression" && (node.operator === "+" || node.operator === "-") && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+        return JSON.stringify(["literal", "number", `${node.operator}${node.argument.value}`]);
+    }
+    if (node.type === "ArrayExpression") {
+        const values = node.elements.map((element) => element === null || element.type === "SpreadElement" ? null : staticValue(element));
+        return values.some((value) => value === null) ? null : JSON.stringify(["array", values]);
+    }
+    if (node.type === "ObjectExpression") {
+        const properties = [];
+        for (const property of node.properties) {
+            if (property.type !== "Property" || property.computed || property.method || property.kind !== "init" || property.key.type !== "Identifier" && property.key.type !== "Literal")
+                return null;
+            const value = staticValue(property.value);
+            if (value === null)
+                return null;
+            const key = property.key.type === "Identifier" ? property.key.name : String(property.key.value);
+            properties.push([key, value]);
+        }
+        return JSON.stringify(["object", properties]);
+    }
+    return null;
+}
+/** Report static all-caps constants duplicated by name and value in another file. */
+export const noDuplicateConstsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Report all-caps constants duplicated by name and static value across files" },
+        messages: { duplicate: "{{name}} duplicates the constant in {{firstFile}}." },
+        schema: [],
+    },
+    createOnce(context) {
+        const seen = new Map();
+        return {
+            Program() {
+                // LSPs can re-lint a file in the same worker; discard stale entries first.
+                for (const [key, constant] of seen)
+                    if (constant.filename === context.filename)
+                        seen.delete(key);
+            },
+            VariableDeclaration(node) {
+                if (node.kind !== "const")
+                    return;
+                for (const declaration of node.declarations) {
+                    if (declaration.id.type !== "Identifier" || !/^[A-Z][A-Z0-9_]*$/.test(declaration.id.name) || declaration.init === null)
+                        continue;
+                    const value = staticValue(declaration.init);
+                    if (value === null)
+                        continue;
+                    const key = `${declaration.id.name}:${value}`, first = seen.get(key);
+                    if (first === undefined) {
+                        seen.set(key, { filename: context.filename, name: declaration.id.name });
+                    }
+                    else if (first.filename !== context.filename) {
+                        context.report({ node: declaration, messageId: "duplicate", data: { name: declaration.id.name, firstFile: first.filename } });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-duplicate-types/drizzle.js

@@ -10,7 +10,9 @@ function canonicalIntegerType(node, builder) {
             return null;
         mode = property.value.value;
     }
-    return mode === null ? builder.type : mode === "boolean" ? "TSBooleanKeyword" : null;
+    if (mode === null || mode === "number")
+        return builder.type;
+    return mode === "boolean" ? "TSBooleanKeyword" : null;
 }
 function canonicalColumn(node, builders) {
     let current = node, notNull = false, hasDefault = false, typeOverride = null;

package/dist/rules/no-duplicate-types.js

@@ -105,7 +105,24 @@ export const noDuplicateTypesRule = defineRule({
             }
         };
         return {
-            Program() { options = context.options[0] ?? {}; },
+            Program() {
+                // LSPs can re-lint a file in the same createOnce worker; discard its stale declarations first.
+                for (const [key, type] of seen)
+                    if (type.filename === context.filename)
+                        seen.delete(key);
+                options = context.options[0] ?? {};
+                zodNamespaces.clear();
+                valibotNamespaces.clear();
+                arkTypeFunctions.clear();
+                valibotFunctions.clear();
+                drizzleTables.clear();
+                drizzleSchemaFactories.clear();
+                drizzleSchemaObjects.clear();
+                drizzleBuilders.clear();
+                drizzleModels.clear();
+                drizzleAliases.length = 0;
+                hasArkTypeImport = false;
+            },
             ImportDeclaration: trackImport,
             TSTypeAliasDeclaration(node) { inspectType(node); drizzleAliases.push(node); },
             TSInterfaceDeclaration: inspectType,

package/dist/rules/no-poor-substring-tests.d.ts

@@ -0,0 +1,2 @@
+/** Disallow testing that a constant string contains substrings. */
+export declare const noPoorSubstringTestsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-poor-substring-tests.js

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defineRule } from "@oxlint/plugins";
+import { resolveVariable } from "../shared/scope.js";
+const SUBSTRING_MATCHERS = new Set([
+    "toContain",
+    "toInclude",
+    "toMatch",
+    "include",
+    "contain",
+    "string",
+    "match",
+]);
+const CHAIN_MODIFIERS = new Set([
+    "not",
+    "resolves",
+    "rejects",
+    "to",
+    "be",
+    "have",
+    "that",
+    "which",
+    "and",
+    "is",
+    "deep",
+    "nested",
+    "own",
+]);
+const SUBSTRING_METHODS = new Set([
+    "includes",
+    "startsWith",
+    "endsWith",
+    "indexOf",
+    "search",
+    "match",
+]);
+const ASSERT_MATCHERS = new Set([
+    "include",
+    "includes",
+    "notInclude",
+    "notIncludes",
+    "match",
+    "notMatch",
+]);
+const fileContentCache = new Map();
+function isTestFile(filename) {
+    if (!filename)
+        return false;
+    return /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)|(?:[._](?:test|spec))\.[cm]?[jt]sx?$/i.test(filename);
+}
+function rootIdentifierName(node) {
+    let current = 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 unwrapExpression(expression) {
+    let current = expression;
+    while (true) {
+        if (current.type === "ParenthesizedExpression" ||
+            current.type === "TSAsExpression" ||
+            current.type === "TSTypeAssertion" ||
+            current.type === "TSNonNullExpression" ||
+            current.type === "TSSatisfiesExpression") {
+            current = current.expression;
+        }
+        else {
+            break;
+        }
+    }
+    return current;
+}
+function isStableConstVariable(variable, declarator) {
+    if (declarator.parent.type !== "VariableDeclaration")
+        return false;
+    if (declarator.parent.kind === "const")
+        return true;
+    return variable.references.every((ref) => ref.init || !ref.isWrite());
+}
+function isImportedConstantString(variable, currentFilename) {
+    if (!currentFilename || !path.isAbsolute(currentFilename))
+        return false;
+    const definition = variable.defs[0];
+    if (definition?.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+        return false;
+    }
+    const source = definition.parent.source.value;
+    if (typeof source !== "string" || !source.startsWith(".")) {
+        return false;
+    }
+    const dir = path.dirname(currentFilename);
+    const candidates = [
+        path.resolve(dir, source),
+        path.resolve(dir, `${source}.ts`),
+        path.resolve(dir, `${source}.tsx`),
+        path.resolve(dir, `${source}.js`),
+        path.resolve(dir, `${source}.mjs`),
+        path.resolve(dir, source, "index.ts"),
+        path.resolve(dir, source, "index.js"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            let content = fileContentCache.get(candidate);
+            if (content === undefined) {
+                if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) {
+                    continue;
+                }
+                content = fs.readFileSync(candidate, "utf8");
+                fileContentCache.set(candidate, content);
+            }
+            const importedName = definition.node.type === "ImportSpecifier"
+                ? definition.node.imported.type === "Identifier"
+                    ? definition.node.imported.name
+                    : definition.node.imported.value
+                : definition.node.type === "ImportDefaultSpecifier"
+                    ? "default"
+                    : null;
+            if (!importedName)
+                continue;
+            const pattern = new RegExp(`export\\s+const\\s+${importedName}\\s*=\\s*(["'\`])`);
+            if (pattern.test(content)) {
+                return true;
+            }
+        }
+        catch {
+            // ignore file read errors
+        }
+    }
+    return false;
+}
+function isConstantString(expression, sourceCode, currentFilename, visited = new Set()) {
+    const current = unwrapExpression(expression);
+    if (current.type === "Literal" && typeof current.value === "string") {
+        return true;
+    }
+    if (current.type === "TemplateLiteral") {
+        if (current.expressions.length === 0) {
+            return true;
+        }
+        return current.expressions.every((expr) => isConstantString(expr, sourceCode, currentFilename, visited));
+    }
+    if (current.type === "BinaryExpression" && current.operator === "+") {
+        return (isConstantString(current.left, sourceCode, currentFilename, visited) &&
+            isConstantString(current.right, sourceCode, currentFilename, visited));
+    }
+    if (current.type === "CallExpression" &&
+        current.callee.type === "Identifier" &&
+        current.callee.name === "String" &&
+        current.arguments.length === 1 &&
+        current.arguments[0]?.type !== "SpreadElement") {
+        return isConstantString(current.arguments[0], sourceCode, currentFilename, visited);
+    }
+    if (current.type === "Identifier") {
+        const variable = resolveVariable(sourceCode, current);
+        if (variable === null || visited.has(variable)) {
+            return false;
+        }
+        if (variable.defs.length === 1) {
+            const [def] = variable.defs;
+            if (def?.type === "Variable" &&
+                def.node.type === "VariableDeclarator" &&
+                def.node.init !== null) {
+                if (isStableConstVariable(variable, def.node)) {
+                    visited.add(variable);
+                    return isConstantString(def.node.init, sourceCode, currentFilename, visited);
+                }
+            }
+            if (def?.type === "ImportBinding") {
+                return isImportedConstantString(variable, currentFilename);
+            }
+        }
+    }
+    return false;
+}
+function extractExpectSubject(callee) {
+    let object = callee.object;
+    while (object.type === "MemberExpression" &&
+        !object.computed &&
+        object.property.type === "Identifier" &&
+        CHAIN_MODIFIERS.has(object.property.name)) {
+        object = object.object;
+    }
+    if (object.type === "CallExpression" &&
+        rootIdentifierName(object.callee) === "expect" &&
+        object.arguments.length > 0 &&
+        object.arguments[0]?.type !== "SpreadElement") {
+        return object.arguments[0];
+    }
+    return null;
+}
+function extractSubstringCallSubject(node) {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === "CallExpression" &&
+        unwrapped.callee.type === "MemberExpression" &&
+        !unwrapped.callee.computed &&
+        unwrapped.callee.property.type === "Identifier") {
+        const method = unwrapped.callee.property.name;
+        if (SUBSTRING_METHODS.has(method)) {
+            return unwrapped.callee.object;
+        }
+        if (method === "test" && unwrapped.arguments.length > 0 && unwrapped.arguments[0]?.type !== "SpreadElement") {
+            return unwrapped.arguments[0];
+        }
+    }
+    if (unwrapped.type === "BinaryExpression") {
+        if (unwrapped.left.type !== "PrivateIdentifier") {
+            const leftSubject = extractSubstringCallSubject(unwrapped.left);
+            if (leftSubject)
+                return leftSubject;
+        }
+        const rightSubject = extractSubstringCallSubject(unwrapped.right);
+        if (rightSubject)
+            return rightSubject;
+    }
+    return null;
+}
+function isExpectStringContaining(node) {
+    const unwrapped = unwrapExpression(node);
+    if (unwrapped.type === "CallExpression" &&
+        unwrapped.callee.type === "MemberExpression" &&
+        !unwrapped.callee.computed &&
+        unwrapped.callee.property.type === "Identifier" &&
+        unwrapped.callee.property.name === "stringContaining" &&
+        rootIdentifierName(unwrapped.callee.object) === "expect") {
+        return true;
+    }
+    return false;
+}
+/** Disallow testing that a constant string contains substrings. */
+export const noPoorSubstringTestsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Disallow testing that a constant string contains substrings; tests must assert on dynamic behavior or verify full contracts.",
+        },
+        messages: {
+            poorSubstringTest: "Testing that a constant string contains a substring provides little signal. Assert against dynamic behavior, or verify the complete contract with an exact match or snapshot instead.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        let shouldCheck = false;
+        return {
+            Program() {
+                shouldCheck = isTestFile(context.filename);
+            },
+            CallExpression(node) {
+                if (!shouldCheck)
+                    return;
+                // Pattern 1: expect(subject).toContain(sub), expect(subject).toMatch(regex), etc.
+                if (node.callee.type === "MemberExpression" &&
+                    !node.callee.computed &&
+                    node.callee.property.type === "Identifier") {
+                    const propertyName = node.callee.property.name;
+                    if (SUBSTRING_MATCHERS.has(propertyName)) {
+                        const subject = extractExpectSubject(node.callee);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                    // Pattern 1b: expect(subject).toEqual(expect.stringContaining(sub))
+                    if (node.arguments.length > 0 &&
+                        node.arguments[0] !== undefined &&
+                        node.arguments[0].type !== "SpreadElement" &&
+                        isExpectStringContaining(node.arguments[0])) {
+                        const subject = extractExpectSubject(node.callee);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                }
+                // Pattern 2: expect(subject.includes("sub")), expect(subject.startsWith("sub")), expect(/regex/.test(subject)), etc.
+                if (rootIdentifierName(node.callee) === "expect" && node.arguments.length > 0) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg && firstArg.type !== "SpreadElement") {
+                        const subject = extractSubstringCallSubject(firstArg);
+                        if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                }
+                // Pattern 3: assert(subject.includes("sub")), assert.ok(subject.includes("sub")), assert.isTrue(subject.includes("sub"))
+                if (rootIdentifierName(node.callee) === "assert" &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0] !== undefined &&
+                    node.arguments[0].type !== "SpreadElement") {
+                    const firstArg = node.arguments[0];
+                    // 3a: assert.include(subject, "sub"), assert.match(subject, /regex/)
+                    if (node.callee.type === "MemberExpression" &&
+                        !node.callee.computed &&
+                        node.callee.property.type === "Identifier" &&
+                        ASSERT_MATCHERS.has(node.callee.property.name)) {
+                        if (isConstantString(firstArg, context.sourceCode, context.filename)) {
+                            context.report({ node, messageId: "poorSubstringTest" });
+                            return;
+                        }
+                    }
+                    // 3b: assert(subject.includes("sub")), assert.ok(subject.includes("sub"))
+                    const subject = extractSubstringCallSubject(firstArg);
+                    if (subject && isConstantString(subject, context.sourceCode, context.filename)) {
+                        context.report({ node, messageId: "poorSubstringTest" });
+                    }
+                }
+            },
+        };
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-deslop",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
   "type": "module",
   "main": "./dist/index.js",