@commonplaces/oxlint-plugin 0.0.0-stage → 0.1.1

package/dist/effect.js

@@ -0,0 +1,352 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option, Predicate, Schema } from "effect";
+import { childNodes, propertyName, variableInScope } from "./syntax.js";
+const memberExpressionName = (node) => {
+    if (node?.type !== "MemberExpression" || node.object?.type !== "Identifier") {
+        return Option.none();
+    }
+    const property = propertyName(node.property);
+    const objectName = node.object.name;
+    return Option.map(property, (name) => `${objectName}.${name}`);
+};
+const isMemberCall = (node, objectName, methodName) => node?.type === "CallExpression" &&
+    node.callee?.type === "MemberExpression" &&
+    node.callee.object?.type === "Identifier" &&
+    node.callee.object.name === objectName &&
+    Option.contains(propertyName(node.callee.property), methodName);
+const noAmbientProcess = defineRule({
+    create(context) {
+        return {
+            MemberExpression(node) {
+                if (Option.exists(memberExpressionName(node), (name) => Array.contains(["process.argv", "process.env", "process.exit"], name))) {
+                    context.report({ messageId: "noAmbientProcess", node });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow ambient process input and exit control." },
+        messages: {
+            noAmbientProcess: "Use decoded command input, Effect Config and typed command results instead of ambient process state.",
+        },
+        type: "problem",
+    },
+});
+const noRawFetch = defineRule({
+    create(context) {
+        return {
+            CallExpression(node) {
+                const isBareFetch = node.callee?.type === "Identifier" && node.callee.name === "fetch";
+                const isGlobalFetch = node.callee?.type === "MemberExpression" &&
+                    node.callee.object?.type === "Identifier" &&
+                    ["globalThis", "window"].includes(node.callee.object.name) &&
+                    Option.contains(propertyName(node.callee.property), "fetch");
+                if (isBareFetch || isGlobalFetch) {
+                    context.report({ messageId: "noRawFetch", node: node.callee });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow raw fetch in Effect-owned TypeScript." },
+        messages: {
+            noRawFetch: "Use Effect HttpClient and decode the response with its owning Schema.",
+        },
+        type: "problem",
+    },
+});
+const noUncheckedJson = defineRule({
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (isMemberCall(node, "JSON", "parse")) {
+                    context.report({ messageId: "noUncheckedJson", node: node.callee });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow JSON.parse without an owning Schema." },
+        messages: {
+            noUncheckedJson: "Decode JSON text with the owning Effect Schema.",
+        },
+        type: "problem",
+    },
+});
+const noConsole = defineRule({
+    create(context) {
+        return {
+            MemberExpression(node) {
+                if (node.object?.type === "Identifier" && node.object.name === "console") {
+                    context.report({ messageId: "noConsole", node });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow raw console calls in Effect-owned TypeScript." },
+        messages: {
+            noConsole: "Use Effect Console or structured Effect logging.",
+        },
+        type: "problem",
+    },
+});
+const isFunctionNode = (node) => node.type === "ArrowFunctionExpression" ||
+    node.type === "FunctionDeclaration" ||
+    node.type === "FunctionExpression";
+const nearestFunction = (node) => node === null
+    ? Option.none()
+    : isFunctionNode(node)
+        ? Option.some(node)
+        : nearestFunction(node.parent);
+const isAllowedPromiseBoundary = (node) => {
+    const parent = node?.parent;
+    if (parent?.type === "CallExpression" && parent.arguments?.includes(node)) {
+        return (parent.callee?.type === "MemberExpression" &&
+            parent.callee.object?.type === "Identifier" &&
+            parent.callee.object.name === "Effect" &&
+            Option.exists(propertyName(parent.callee.property), (name) => Array.contains(["promise", "tryPromise"], name)));
+    }
+    if (parent?.type !== "Property" || !Option.contains(propertyName(parent.key), "try")) {
+        return false;
+    }
+    const options = parent.parent;
+    const call = options?.parent;
+    return (options?.type === "ObjectExpression" &&
+        call?.type === "CallExpression" &&
+        call.arguments?.includes(options) &&
+        call.callee?.type === "MemberExpression" &&
+        call.callee.object?.type === "Identifier" &&
+        call.callee.object.name === "Effect" &&
+        Option.contains(propertyName(call.callee.property), "tryPromise"));
+};
+const noAsyncAwaitPromise = defineRule({
+    create(context) {
+        const reportAsync = (node) => {
+            if (node.async && !isAllowedPromiseBoundary(node)) {
+                context.report({ messageId: "noAsync", node });
+            }
+        };
+        return {
+            ArrowFunctionExpression: reportAsync,
+            AwaitExpression(node) {
+                if (!Option.exists(nearestFunction(node.parent), isAllowedPromiseBoundary)) {
+                    context.report({ messageId: "noAwait", node });
+                }
+            },
+            FunctionDeclaration: reportAsync,
+            FunctionExpression: reportAsync,
+            Identifier(node) {
+                if (node.name === "Promise" &&
+                    node.parent?.type === "TSTypeReference" &&
+                    node.parent.typeName === node) {
+                    context.report({ messageId: "noPromiseType", node });
+                }
+            },
+            NewExpression(node) {
+                if (node.callee?.type === "Identifier" && node.callee.name === "Promise") {
+                    context.report({ messageId: "noPromise", node: node.callee });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow raw Promise and async orchestration." },
+        messages: {
+            noAsync: "Return an Effect program instead of declaring an async function.",
+            noAwait: "Compose Effect programs instead of awaiting raw Promises.",
+            noPromise: "Use Effect.async, Effect.promise or Effect.tryPromise at the host boundary.",
+            noPromiseType: "Expose an Effect result instead of a raw Promise type.",
+        },
+        type: "problem",
+    },
+});
+const noInstanceof = defineRule({
+    create(context) {
+        return {
+            BinaryExpression(node) {
+                if (node.operator === "instanceof") {
+                    context.report({ messageId: "noInstanceof", node });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Disallow instanceof checks in Effect-owned TypeScript." },
+        messages: {
+            noInstanceof: "Use tagged data, Schema guards or Effect matchers instead of instanceof.",
+        },
+        type: "problem",
+    },
+});
+const isManualTagKey = (node) => {
+    const parent = node?.parent;
+    if (!Option.contains(propertyName(node), "_tag")) {
+        return false;
+    }
+    if (parent?.type === "MemberExpression") {
+        return parent.property === node;
+    }
+    if (parent?.type === "Property" ||
+        parent?.type === "PropertyDefinition" ||
+        parent?.type === "TSPropertySignature") {
+        return parent.key === node;
+    }
+    return false;
+};
+const noManualTag = defineRule({
+    create(context) {
+        const reportTag = (node) => {
+            if (isManualTagKey(node)) {
+                context.report({ messageId: "noManualTag", node });
+            }
+        };
+        return {
+            Identifier: reportTag,
+            Literal: reportTag,
+        };
+    },
+    meta: {
+        docs: { description: "Disallow manual Effect tag definitions and checks." },
+        messages: {
+            noManualTag: "Use Data or Schema tagged classes to define variants, then use Match, Schema.is or the matching Effect primitive to inspect them.",
+        },
+        type: "problem",
+    },
+});
+const RuntimeOptions = Schema.Struct({ allowedFiles: Schema.Array(Schema.String) });
+const ServiceOptions = Schema.Struct({ serviceNames: Schema.Array(Schema.String) });
+const noRuntimeExecutionOutsideMain = defineRule({
+    meta: {
+        type: "problem",
+        schema: [
+            {
+                type: "object",
+                properties: { allowedFiles: { type: "array", items: { type: "string", minLength: 1 } } },
+                required: ["allowedFiles"],
+                additionalProperties: false,
+            },
+        ],
+        docs: { description: "Restrict Effect runtime execution to configured entry files." },
+        messages: {
+            noRuntimeExecutionOutsideMain: "Only configured entry files may execute the Effect runtime. Packages return Effect programs.",
+        },
+    },
+    create(context) {
+        // Oxlint requires a synchronous create callback; invalid options stop linting.
+        const options = Schema.decodeUnknownSync(RuntimeOptions)(Option.getOrElse(Array.head(context.options), () => ({ allowedFiles: [] })));
+        const filename = context.filename.replaceAll("\\", "/");
+        const cwd = context.cwd.replaceAll("\\", "/").replace(/\/$/u, "");
+        const relative = filename.startsWith(`${cwd}/`) ? filename.slice(cwd.length + 1) : filename;
+        const isMain = Array.contains(options.allowedFiles, relative);
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier")
+                    return;
+                const object = node.callee.object.name;
+                const method = propertyName(node.callee.property);
+                const isRunner = Option.exists(method, (name) => (object === "Effect" && name.startsWith("run")) ||
+                    ((object === "BunRuntime" || object === "NodeRuntime") && name === "runMain"));
+                if (isRunner && !isMain)
+                    context.report({ messageId: "noRuntimeExecutionOutsideMain", node: node.callee });
+            },
+        };
+    },
+});
+const instrumentationName = (node) => {
+    if (node.type !== "CallExpression" ||
+        node.callee.type !== "MemberExpression" ||
+        node.callee.object.type !== "Identifier" ||
+        node.callee.object.name !== "Effect" ||
+        !Option.exists(propertyName(node.callee.property), (name) => Array.contains(["fn", "withSpan"], name)))
+        return Option.none();
+    return Array.head(node.arguments).pipe(Option.flatMap((argument) => argument.type === "Literal" && Predicate.isString(argument.value)
+        ? Option.some(argument.value)
+        : Option.none()));
+};
+const containsInstrumentation = (context, node, name) => Option.contains(instrumentationName(node), name) ||
+    Array.some(childNodes(context, node), (child) => containsInstrumentation(context, child, name));
+const operationValue = (context, node) => {
+    if (node.type !== "Identifier")
+        return Option.some(node);
+    return variableInScope(context.sourceCode.getScope(node), node.name).pipe(Option.flatMap((variable) => Array.head(variable.defs)), Option.flatMap((definition) => definition.node.type === "VariableDeclarator"
+        ? Option.fromNullishOr(definition.node.init)
+        : Option.none()));
+};
+const requireServiceOperationInstrumentation = defineRule({
+    meta: {
+        type: "problem",
+        schema: [
+            {
+                type: "object",
+                properties: { serviceNames: { type: "array", items: { type: "string", minLength: 1 } } },
+                required: ["serviceNames"],
+                additionalProperties: false,
+            },
+        ],
+        docs: {
+            description: "Require exact tracing names on configured public Effect service operations.",
+        },
+        messages: {
+            missingInstrumentation: "Instrument {{operation}} with Effect.fn or Effect.withSpan using that exact name.",
+            unsupportedOperation: "Declare public Effect service operations as named object properties so tracing can be checked.",
+        },
+    },
+    create(context) {
+        // Oxlint requires a synchronous create callback; invalid options stop linting.
+        const options = Schema.decodeUnknownSync(ServiceOptions)(Option.getOrUndefined(Array.head(context.options)));
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" ||
+                    node.callee.object.type !== "Identifier" ||
+                    !Array.contains(options.serviceNames, node.callee.object.name) ||
+                    !Option.contains(propertyName(node.callee.property), "of"))
+                    return;
+                const service = node.callee.object.name;
+                const operations = Array.head(node.arguments);
+                Option.match(operations, {
+                    onNone: () => { },
+                    onSome: (argument) => {
+                        if (argument.type !== "ObjectExpression")
+                            return;
+                        Array.forEach(argument.properties, (operation) => {
+                            if (operation.type !== "Property") {
+                                context.report({ messageId: "unsupportedOperation", node: operation });
+                                return;
+                            }
+                            Option.match(propertyName(operation.key), {
+                                onNone: () => {
+                                    context.report({ messageId: "unsupportedOperation", node: operation });
+                                },
+                                onSome: (name) => {
+                                    const fullName = `${service}.${name}`;
+                                    if (!Option.exists(operationValue(context, operation.value), (value) => containsInstrumentation(context, value, fullName))) {
+                                        context.report({
+                                            messageId: "missingInstrumentation",
+                                            data: { operation: fullName },
+                                            node: operation,
+                                        });
+                                    }
+                                },
+                            });
+                        });
+                    },
+                });
+            },
+        };
+    },
+});
+export default {
+    meta: { name: "effect" },
+    rules: {
+        "no-ambient-process": noAmbientProcess,
+        "no-async-await-promise": noAsyncAwaitPromise,
+        "no-console": noConsole,
+        "no-instanceof": noInstanceof,
+        "no-manual-tag": noManualTag,
+        "no-raw-fetch": noRawFetch,
+        "no-runtime-execution-outside-main": noRuntimeExecutionOutsideMain,
+        "no-unchecked-json": noUncheckedJson,
+        "require-service-operation-instrumentation": requireServiceOperationInstrumentation,
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+/** General code checks, with no project-specific file names or settings. */
+export declare const general: {
+    jsPlugins: string[];
+    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";
+        "package/no-cross-package-source-imports": "error";
+    };
+};
+/** Effect code checks. Add the general group separately if wanted. */
+export declare const effect: {
+    jsPlugins: string[];
+    rules: {
+        "effect/no-ambient-process": "error";
+        "effect/no-async-await-promise": "error";
+        "effect/no-console": "error";
+        "effect/no-instanceof": "error";
+        "effect/no-manual-tag": "error";
+        "effect/no-raw-fetch": "error";
+        "strict-effect/static-layers": "error";
+        "strict-effect/no-unchecked-index": "error";
+        "strict-effect/no-native-at": "error";
+        "strict-effect/tagged-error-name": "error";
+        "strict-effect/error-constructor-new": "error";
+        "strict-effect/no-promise-workflow": "error";
+        "strict-effect/no-unsafe-option-unwrap": "error";
+        "strict-effect/no-unchecked-json": "error";
+        "strict-effect/no-native-work": "error";
+        "strict-effect/no-imperative-collections": "error";
+        "strict-effect/no-native-client-replica": "error";
+        "bun/no-ambient-host-api": "error";
+        "anti-slop-effect/no-service-constructor-imports": "error";
+    };
+};
+/** Native Alchemy configuration and secret-source checks. */
+export declare const alchemy: {
+    jsPlugins: string[];
+    rules: {
+        "alchemy-secrets/native-sources": "error";
+        "alchemy-secrets/explicit-stack-sources": "error";
+        "alchemy-secrets/no-doppler-wrapper": "error";
+        "strict-effect/native-cloudflare-cache": "error";
+    };
+};

package/dist/index.js

@@ -0,0 +1,62 @@
+/** General code checks, with no project-specific file names or settings. */
+export const general = {
+    jsPlugins: ["@commonplaces/oxlint-plugin/anti-slop", "@commonplaces/oxlint-plugin/package"],
+    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",
+        "package/no-cross-package-source-imports": "error",
+    },
+};
+/** Effect code checks. Add the general group separately if wanted. */
+export const effect = {
+    jsPlugins: [
+        "@commonplaces/oxlint-plugin/effect",
+        "@commonplaces/oxlint-plugin/strict-effect",
+        "@commonplaces/oxlint-plugin/bun",
+        "@commonplaces/oxlint-plugin/anti-slop-effect",
+    ],
+    rules: {
+        "effect/no-ambient-process": "error",
+        "effect/no-async-await-promise": "error",
+        "effect/no-console": "error",
+        "effect/no-instanceof": "error",
+        "effect/no-manual-tag": "error",
+        "effect/no-raw-fetch": "error",
+        "strict-effect/static-layers": "error",
+        "strict-effect/no-unchecked-index": "error",
+        "strict-effect/no-native-at": "error",
+        "strict-effect/tagged-error-name": "error",
+        "strict-effect/error-constructor-new": "error",
+        "strict-effect/no-promise-workflow": "error",
+        "strict-effect/no-unsafe-option-unwrap": "error",
+        "strict-effect/no-unchecked-json": "error",
+        "strict-effect/no-native-work": "error",
+        "strict-effect/no-imperative-collections": "error",
+        "strict-effect/no-native-client-replica": "error",
+        "bun/no-ambient-host-api": "error",
+        "anti-slop-effect/no-service-constructor-imports": "error",
+    },
+};
+/** Native Alchemy configuration and secret-source checks. */
+export const alchemy = {
+    jsPlugins: ["@commonplaces/oxlint-plugin/alchemy", "@commonplaces/oxlint-plugin/strict-effect"],
+    rules: {
+        "alchemy-secrets/native-sources": "error",
+        "alchemy-secrets/explicit-stack-sources": "error",
+        "alchemy-secrets/no-doppler-wrapper": "error",
+        "strict-effect/native-cloudflare-cache": "error",
+    },
+};

package/dist/package.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-cross-package-source-imports": import("@oxlint/plugins").Rule;
+    };
+};
+export default _default;

package/dist/package.js

@@ -0,0 +1,50 @@
+import { defineRule } from "@oxlint/plugins";
+import { Array, Option, Predicate } from "effect";
+const resolveRelative = (fileName, specifier) => Array.join(Array.reduce(specifier.split("/"), Array.dropRight(fileName.split("/"), 1), (segments, segment) => segment === ".."
+    ? Array.dropRight(segments, 1)
+    : segment === "." || segment.length === 0
+        ? segments
+        : [...segments, segment]), "/");
+const workspaceSourceRoot = (fileName) => Option.fromNullishOr(fileName.match(/\/(?:apps|packages)\/(?:[^/]+\/)+?src(?:\/|$)/u)).pipe(Option.flatMap(Array.head), Option.map((root) => root.replace(/\/$/u, "")));
+const isPrivatePackageAlias = (specifier) => /^@[^/]+\/[^/]+\/src(?:\/|$)/u.test(specifier);
+const isCrossWorkspaceSourcePath = (fileName, specifier) => {
+    if (!specifier.startsWith(".")) {
+        return false;
+    }
+    const sourceRoot = workspaceSourceRoot(fileName);
+    const target = resolveRelative(fileName, specifier);
+    const targetRoot = workspaceSourceRoot(target);
+    return Option.exists(Option.all([sourceRoot, targetRoot]), ([source, target]) => source !== target);
+};
+const noCrossPackageSourceImports = defineRule({
+    create(context) {
+        const fileName = context.filename.replaceAll("\\", "/");
+        const inspect = (node) => {
+            const source = node.source;
+            if (source?.type === "Literal" &&
+                Predicate.isString(source.value) &&
+                (isPrivatePackageAlias(source.value) || isCrossWorkspaceSourcePath(fileName, source.value))) {
+                context.report({ messageId: "noCrossPackageSourceImports", node: source });
+            }
+        };
+        return {
+            ExportAllDeclaration: inspect,
+            ExportNamedDeclaration: inspect,
+            ImportDeclaration: inspect,
+            ImportExpression: inspect,
+        };
+    },
+    meta: {
+        docs: { description: "Prevent imports from another workspace's private source tree." },
+        messages: {
+            noCrossPackageSourceImports: "Import the package's public export instead of reaching into another workspace's source folder.",
+        },
+        type: "problem",
+    },
+});
+export default {
+    meta: { name: "package" },
+    rules: {
+        "no-cross-package-source-imports": noCrossPackageSourceImports,
+    },
+};

package/dist/strict-effect.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@oxlint/plugins").Plugin;
+export default _default;