sadist 0.1.0

package/LICENSE

@@ -0,0 +1,354 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You.
+    For purposes of this definition, "control" means (a) the power,
+    direct or indirect, to cause the direction or management of such
+    entity, whether by contract or otherwise, or (b) ownership of more
+    than fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants. Each Contributor hereby grants You a world-wide,
+    royalty-free, non-exclusive license:
+
+    (a) under intellectual property rights (other than patent or
+        trademark) Licensable by such Contributor to use, reproduce,
+        make available, modify, display, perform, distribute, and
+        otherwise exploit its Contributions, either on an unmodified
+        basis, with Modifications, or as part of a Larger Work; and
+
+    (b) under Patent Claims of such Contributor to make, use, sell,
+        offer for sale, have made, import, and otherwise transfer
+        either its Contributions or its Contributor Version.
+
+2.2. Effective Date. The licenses granted in Section 2.1 with respect
+    to any Contribution become effective for each Contribution on the
+    date the Contributor first distributes such Contribution.
+
+2.3. Limitations on Grant Scope. The licenses granted in this Section 2
+    are the only rights granted under this License. No additional
+    rights or licenses will be implied from the distribution or
+    licensing of Covered Software under this License. Notwithstanding
+    Section 2.1(b) above, no patent license is granted by a
+    Contributor:
+
+    (a) for any code that a Contributor has removed from Covered
+        Software; or
+
+    (b) for infringements caused by: (i) Your and any other third
+        party's modifications of Covered Software, or (ii) the
+        combination of its Contributions with other software (except
+        as part of its Contributor Version); or
+
+    (c) under Patent Claims infringed by Covered Software in the
+        absence of its Contributions.
+
+    This License does not grant any rights in the trademarks, service
+    marks, or logos of any Contributor (except as may be necessary to
+    comply with the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses. No Contributor makes additional grants as a
+    result of Your choice to distribute the Covered Software under a
+    subsequent version of this License (see Section 10.2) or under the
+    terms of a Secondary License (if permitted under the terms of
+    Section 3.3).
+
+2.5. Representation. Each Contributor represents that the Contributor
+    believes its Contributions are its original creation(s) or it has
+    sufficient rights to grant the rights to its Contributions conveyed
+    by this License.
+
+2.6. Fair Use. This License is not intended to limit any rights You
+    have under applicable copyright doctrines of fair use, fair
+    dealing, or other equivalents.
+
+2.7. Conditions. Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the
+    licenses granted in Section 2.1.
+
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form. All distribution of Covered Software
+    in Source Code Form, including any Modifications that You create or
+    to which You contribute, must be under the terms of this License.
+    You must inform recipients that the Source Code Form of the Covered
+    Software is governed by the terms of this License, and how they can
+    obtain a copy of this License. You may not attempt to alter or
+    restrict the recipients' rights in the Source Code Form.
+
+3.2. Distribution of Executable Form. If You distribute Covered
+    Software in Executable Form then:
+
+    (a) such Covered Software must also be made available in Source
+        Code Form, as described in Section 3.1, and You must inform
+        recipients of the Executable Form how they can obtain a copy of
+        such Source Code Form by reasonable means in a timely manner,
+        at a charge no more than the cost of distribution to the
+        recipient; and
+
+    (b) You may distribute such Executable Form under the terms of
+        this License, or sublicense it under different terms, provided
+        that the license for the Executable Form does not attempt to
+        limit or alter the recipients' rights in the Source Code Form
+        under this License.
+
+3.3. Distribution of a Larger Work. You may create and distribute a
+    Larger Work under terms of Your choice, provided that You also
+    comply with the requirements of this License for the Covered
+    Software. If the Larger Work is a combination of Covered Software
+    with a work governed by one or more Secondary Licenses, and the
+    Covered Software is not Incompatible With Secondary Licenses, this
+    License permits You to additionally distribute such Covered
+    Software under the terms of such Secondary License(s), so that the
+    recipient of the Larger Work may, at their option, further
+    distribute the Covered Software under the terms of either this
+    License or such Secondary License(s).
+
+3.4. Notices. You may not remove or alter the substance of any license
+    notices (including copyright notices, patent notices, disclaimers
+    of warranty, or limitations of liability) contained within the
+    Source Code Form of the Covered Software, except that You may
+    alter any license notices to the extent required to remedy known
+    factual inaccuracies.
+
+3.5. Application of Additional Terms. You may choose to offer, and to
+    charge a fee for, warranty, support, indemnity or liability
+    obligations to one or more recipients of Covered Software.
+    However, You may do so only on Your own behalf, and not on behalf
+    of any Contributor. You must make it absolutely clear that any
+    such warranty, support, indemnity, or liability obligation is
+    offered by You alone, and You hereby agree to indemnify every
+    Contributor for any liability incurred by such Contributor as a
+    result of warranty, support, indemnity or liability terms You
+    offer. You may include additional disclaimers of warranty and
+    limitations of liability specific to any jurisdiction.
+
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description
+must be placed in a text file included with all distributions of the
+Covered Software under this License. Except to the extent prohibited
+by statute or regulation, such description must be sufficiently
+detailed for a recipient of ordinary skill to be able to understand
+it.
+
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+    if You fail to comply with any of its terms. However, if You
+    become compliant, then the rights granted under this License from
+    a particular Contributor are reinstated (a) provisionally, unless
+    and until such Contributor explicitly and finally terminates Your
+    grants, and (b) on an ongoing basis, if such Contributor fails to
+    notify You of the non-compliance by some reasonable means prior to
+    60 days after You have come back into compliance. Moreover, Your
+    grants from a particular Contributor are reinstated on an ongoing
+    basis if such Contributor notifies You of the non-compliance by
+    some reasonable means, this is the first time You have received
+    notice of non-compliance with this License from such Contributor,
+    and You become compliant prior to 30 days after Your receipt of
+    the notice.
+
+5.2. If You initiate litigation against any entity by asserting a
+    patent infringement claim (excluding declaratory judgment actions,
+    counter-claims, and cross-claims) alleging that a Contributor
+    Version directly or indirectly infringes any patent, then the
+    rights granted to You by any and all Contributors for the Covered
+    Software under Section 2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+    end user license agreements (excluding distributors and resellers)
+    which have been validly granted by You or Your distributors under
+    this License prior to termination shall survive termination.
+
+
+6. Disclaimer of Warranty
+-------------------------
+
+Covered Software is provided under this License on an "as is" basis,
+without warranty of any kind, either expressed, implied, or
+statutory, including, without limitation, warranties that the Covered
+Software is free of defects, merchantable, fit for a particular
+purpose or non-infringing. The entire risk as to the quality and
+performance of the Covered Software is with You. Should any Covered
+Software prove defective in any respect, You (not any Contributor)
+assume the cost of any necessary servicing, repair, or correction.
+This disclaimer of warranty constitutes an essential part of this
+License. No use of any Covered Software is authorized under this
+License except under this disclaimer.
+
+
+7. Limitation of Liability
+--------------------------
+
+Under no circumstances and under no legal theory, whether tort
+(including negligence), contract, or otherwise, shall any Contributor,
+or anyone who distributes Covered Software as permitted above, be
+liable to You for any direct, indirect, special, incidental, or
+consequential damages of any character including, without limitation,
+damages for lost profits, loss of goodwill, work stoppage, computer
+failure or malfunction, or any and all other commercial damages or
+losses, even if such party shall have been informed of the possibility
+of such damages. This limitation of liability shall not apply to
+liability for death or personal injury resulting from such party's
+negligence to the extent applicable law prohibits such limitation.
+Some jurisdictions do not allow the exclusion or limitation of
+incidental or consequential damages, so this exclusion and limitation
+may not apply to You.
+
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of
+that jurisdiction, without reference to its conflict-of-law
+provisions. Nothing in this Section shall prevent a party's ability to
+bring cross-claims or counter-claims.
+
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions. Mozilla Foundation is the license steward. Except
+    as provided in Section 10.3, no one other than the license steward
+    has the right to modify or publish new versions of this License.
+    Each version will be given a distinguishing version number.
+
+10.2. Effect of New Versions. You may distribute the Covered Software
+    under the terms of the version of the License under which You
+    originally received the Covered Software, or under the terms of
+    any subsequent version published by the license steward.
+
+10.3. Modified Versions. If you create software not governed by this
+    License, and you want to create a new license for such software,
+    you may create and use a modified version of this License if you
+    rename the license and remove any references to the name of the
+    license steward (except to note that such modified license differs
+    from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With
+    Secondary Licenses. If You choose to distribute Source Code Form
+    that is Incompatible With Secondary Licenses under the terms of
+    this version of the License, the notice described in Exhibit B of
+    this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+    If it is not possible or desirable to put the notice in a
+    particular file, then You may include the notice in a location
+    (such as a LICENSE file in a relevant directory) where a recipient
+    would be likely to look for such a notice.
+
+    You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+----------------------------------------------------------
+
+    This Source Code Form is "Incompatible With Secondary Licenses",
+    as defined by the Mozilla Public License, v. 2.0.

package/README.md

@@ -0,0 +1,130 @@
+# sadist
+
+[![License: MPL-2.0](https://img.shields.io/badge/License-MPL--2.0-blue.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/sadist.svg)](https://www.npmjs.com/package/sadist)
+[![CI](https://github.com/ElBenjaMasLindo/sadist/actions/workflows/ci.yml/badge.svg)](https://github.com/ElBenjaMasLindo/sadist/actions/workflows/ci.yml)
+
+A merciless TypeScript code quality gate.
+
+`sadist` combines strict `tsc` compilation, exhaustive pattern matching via
+`ts-pattern`, and a small set of architectural ESLint rules into a single
+pre-commit gate. Code either passes all three layers or it doesn't get
+committed — there is no partial pass, no warning-only mode, no override
+flag for convenience.
+
+## Why
+
+`any`, silent `null`, unhandled `catch` blocks, and `class` abuse are the
+most common sources of preventable bugs in TypeScript codebases. This isn't
+a style linter that nudges; it's a structural gate that refuses to compile
+or lint code that leaves room for them — see
+[docs/SKILL.md](docs/SKILL.md) for the complete rule set and
+honest coverage (this gate does not, and cannot, catch business-logic bugs;
+only structural ones).
+
+## Install
+
+```bash
+npm install --save-dev sadist
+# or
+pnpm add -D sadist
+```
+
+Requires `typescript >=5.4` and `eslint >=9` as peer dependencies (likely already in your project).
+
+Create `eslint.config.mjs`:
+
+```js
+import strict from "sadist/config/strict";
+export default [...strict];
+```
+
+Add a gate script to `package.json`:
+
+```json
+{
+  "scripts": {
+    "lax": "eslint . && tsc --noEmit"
+  }
+}
+```
+
+Run the gate:
+
+```bash
+npm run lax
+```
+
+If it passes, commit. If it fails, fix the errors first.
+
+## Usage
+
+Example violation of `no-null-in-domain-types`:
+
+```ts
+// ❌ Fails the gate
+type User = {
+  id: string;
+  email: string | null;
+};
+```
+
+Error output:
+
+```
+src/user.ts:3:10 - error: Domain types must not contain null or undefined. Use Option<T> instead.
+```
+
+Fix with `Option<T>`:
+
+```ts
+// ✅ Passes the gate
+import { Option } from "sadist";
+
+type User = {
+  id: string;
+  email: Option<string>;
+};
+```
+
+## API
+
+### Rules
+
+| Rule | What it blocks |
+|------|----------------|
+| `no-any-in-domain-types` | `any` in type aliases, interfaces, function signatures |
+| `no-null-in-domain-types` | `null`/`undefined` in type aliases, interfaces, properties |
+| `no-primitive-obsession` | Raw primitives (`string`, `number`, `boolean`) in object properties |
+| `no-throw-outside-adapters` | `throw` statements outside `src/adapters/` |
+
+### Config
+
+```js
+import strict from "sadist/config/strict";
+export default [...strict];
+```
+
+Enables all 4 rules as errors. No warning-only mode, no partial overrides.
+
+## Versioning
+
+`0.x` — breaking changes allowed in MINOR versions. `1.0.0` means a public API commitment; don't expect it until the rule set is stable.
+
+## Known limitations
+
+- Does not catch business-logic bugs (only structural ones)
+- Requires `ts-pattern` for exhaustive pattern matching (not enforced by rules)
+- No autofix for architectural violations (by design)
+- Assumes `src/adapters/` directory exists for throw statements
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for rules on adding new rules and pre-PR checks.
+
+## License
+
+[Mozilla Public License 2.0](https://mozilla.org/MPL/2.0/) — behaves like MIT when you
+`npm install` and use it as-is: no copyleft obligation on your code. Only
+applies if you modify sadist's own source files. See [LICENSE](LICENSE) for
+full terms.

package/dist/config/strict.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+declare const strictConfig: Linter.Config[];
+export default strictConfig;

package/dist/config/strict.js

@@ -0,0 +1,37 @@
+import { rules } from "../rules/index.js";
+const strictConfig = [
+    {
+        plugins: {
+            sadist: { rules },
+        },
+        rules: {
+            "sadist/no-throw-outside-adapters": "error",
+            "sadist/no-null-in-domain-types": "error",
+            "sadist/no-single-use-generics": "error",
+            "sadist/no-primitive-obsession": "error",
+            complexity: ["error", 6],
+            "max-lines-per-function": ["error", 20],
+            "max-params": ["error", 3],
+            "no-restricted-syntax": [
+                "error",
+                {
+                    selector: "ClassDeclaration",
+                    message: "No classes in domain logic. Use functions and discriminated unions.",
+                },
+                {
+                    selector: "ClassExpression",
+                    message: "No classes in domain logic. Use functions and discriminated unions.",
+                },
+                {
+                    selector: "TSAnyKeyword",
+                    message: "No any. Use a specific type.",
+                },
+                {
+                    selector: "TSNonNullExpression",
+                    message: "No non-null assertions (!). Handle the nullable case explicitly.",
+                },
+            ],
+        },
+    },
+];
+export default strictConfig;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type Option<T> = {
+    some: true;
+    value: T;
+} | {
+    some: false;
+};
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/rules/index.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "eslint";
+export declare const rules: Record<string, Rule.RuleModule>;

package/dist/rules/index.js

@@ -0,0 +1,10 @@
+import noThrowOutsideAdapters from "./no-throw-outside-adapters.js";
+import noNullInDomainTypes from "./no-null-in-domain-types.js";
+import noSingleUseGenerics from "./no-single-use-generics.js";
+import noPrimitiveObsession from "./no-primitive-obsession.js";
+export const rules = {
+    "no-throw-outside-adapters": noThrowOutsideAdapters,
+    "no-null-in-domain-types": noNullInDomainTypes,
+    "no-single-use-generics": noSingleUseGenerics,
+    "no-primitive-obsession": noPrimitiveObsession,
+};

package/dist/rules/no-null-in-domain-types.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "eslint";
+declare const noNullInDomainTypes: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+        };
+        schema: never[];
+    };
+    create(context: Rule.RuleContext): {
+        "TSTypeAliasDeclaration TSNullKeyword"?: never;
+        "TSTypeAliasDeclaration TSUndefinedKeyword"?: never;
+        "TSInterfaceDeclaration TSNullKeyword"?: never;
+        "TSInterfaceDeclaration TSUndefinedKeyword"?: never;
+    } | {
+        "TSTypeAliasDeclaration TSNullKeyword": (node: Rule.Node) => void;
+        "TSTypeAliasDeclaration TSUndefinedKeyword": (node: Rule.Node) => void;
+        "TSInterfaceDeclaration TSNullKeyword": (node: Rule.Node) => void;
+        "TSInterfaceDeclaration TSUndefinedKeyword": (node: Rule.Node) => void;
+    };
+};
+export default noNullInDomainTypes;

package/dist/rules/no-null-in-domain-types.js

@@ -0,0 +1,29 @@
+const noNullInDomainTypes = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "No null or undefined in type aliases or interfaces outside src/adapters/.",
+        },
+        schema: [],
+    },
+    create(context) {
+        const filename = context.filename ?? context.getFilename();
+        if (filename.includes("/adapters/"))
+            return {};
+        function report(msg) {
+            return (node) => {
+                context.report({
+                    node,
+                    message: `No ${msg} in domain types. Use Option<T> instead.`,
+                });
+            };
+        }
+        return {
+            "TSTypeAliasDeclaration TSNullKeyword": report("null"),
+            "TSTypeAliasDeclaration TSUndefinedKeyword": report("undefined"),
+            "TSInterfaceDeclaration TSNullKeyword": report("null"),
+            "TSInterfaceDeclaration TSUndefinedKeyword": report("undefined"),
+        };
+    },
+};
+export default noNullInDomainTypes;

package/dist/rules/no-primitive-obsession.d.ts

@@ -0,0 +1,22 @@
+import type { Rule } from "eslint";
+type TSPropertyNode = Rule.Node & {
+    key?: Record<string, unknown>;
+    typeAnnotation?: {
+        typeAnnotation?: {
+            type: string;
+        };
+    };
+};
+declare const noPrimitiveObsession: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+        };
+        schema: never[];
+    };
+    create(context: Rule.RuleContext): {
+        TSPropertySignature(node: TSPropertyNode): void;
+    };
+};
+export default noPrimitiveObsession;

package/dist/rules/no-primitive-obsession.js

@@ -0,0 +1,37 @@
+function getIdName(node) {
+    const key = node.key;
+    return key?.name?.endsWith("Id") ? key.name : null;
+}
+function isBarePrimitive(node) {
+    return node.typeAnnotation?.typeAnnotation?.type === "TSStringKeyword"
+        || node.typeAnnotation?.typeAnnotation?.type === "TSNumberKeyword";
+}
+function isBarePrimitiveId(node) {
+    const name = getIdName(node);
+    if (!name)
+        return null;
+    return isBarePrimitive(node) ? name : null;
+}
+const noPrimitiveObsession = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "ID properties must use branded types, not bare primitives.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            TSPropertySignature(node) {
+                const idName = isBarePrimitiveId(node);
+                if (idName) {
+                    context.report({
+                        node,
+                        message: `Property "${idName}" is a bare primitive. Use a branded type: string & { readonly __brand: "${idName}" }.`,
+                    });
+                }
+            },
+        };
+    },
+};
+export default noPrimitiveObsession;

package/dist/rules/no-single-use-generics.d.ts

@@ -0,0 +1,26 @@
+import type { Rule } from "eslint";
+type TypeParams = {
+    params: Array<{
+        name: {
+            name: string;
+        };
+    }>;
+};
+type GenericNode = Rule.Node & {
+    typeParameters?: TypeParams;
+};
+declare const noSingleUseGenerics: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+        };
+        schema: never[];
+    };
+    create(context: Rule.RuleContext): {
+        FunctionDeclaration: (node: GenericNode) => void;
+        FunctionExpression: (node: GenericNode) => void;
+        ArrowFunctionExpression: (node: GenericNode) => void;
+    };
+};
+export default noSingleUseGenerics;

package/dist/rules/no-single-use-generics.js

@@ -0,0 +1,31 @@
+function check(context, node) {
+    if (!node.typeParameters)
+        return;
+    const fullText = (context.sourceCode ?? context.getSourceCode()).getText(node);
+    for (const param of node.typeParameters.params) {
+        const name = param.name.name;
+        const matches = fullText.match(new RegExp(`\\b${name}\\b`, "g")) ?? [];
+        if (matches.length <= 2) {
+            context.report({
+                node,
+                message: `Generic "${name}" is used only once. Remove it or use it in more than one place.`,
+            });
+        }
+    }
+}
+const noSingleUseGenerics = {
+    meta: {
+        type: "problem",
+        docs: { description: "No generic type parameter used only once." },
+        schema: [],
+    },
+    create(context) {
+        const visitor = (node) => check(context, node);
+        return {
+            FunctionDeclaration: visitor,
+            FunctionExpression: visitor,
+            ArrowFunctionExpression: visitor,
+        };
+    },
+};
+export default noSingleUseGenerics;

package/dist/rules/no-throw-outside-adapters.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+declare const noThrowOutsideAdapters: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+        };
+        schema: never[];
+    };
+    create(context: Rule.RuleContext): {
+        ThrowStatement?: never;
+    } | {
+        ThrowStatement(node: Rule.Node): void;
+    };
+};
+export default noThrowOutsideAdapters;

package/dist/rules/no-throw-outside-adapters.js

@@ -0,0 +1,21 @@
+const noThrowOutsideAdapters = {
+    meta: {
+        type: "problem",
+        docs: { description: "No throw statements outside src/adapters/." },
+        schema: [],
+    },
+    create(context) {
+        const filename = context.filename ?? context.getFilename();
+        if (filename.includes("/adapters/"))
+            return {};
+        return {
+            ThrowStatement(node) {
+                context.report({
+                    node,
+                    message: "No throw outside src/adapters/. Return a Result instead.",
+                });
+            },
+        };
+    },
+};
+export default noThrowOutsideAdapters;

package/docs/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: sadist-gate
+description: Use when writing or editing TypeScript code inside a repository that has the sadist gate installed (a strict tsc + ts-pattern + ESLint pre-commit gate). Apply before writing any function, type, or commit in such a repo — code that violates these rules will not compile or will fail lint, blocking the commit.
+---
+
+# sadist-gate
+
+Write code that passes on the first attempt. These are hard rules, not style preferences.
+
+## Rules
+
+1. **No `null`/`undefined` in domain types.** Use:
+   ```ts
+   type Option<T> = { some: true; value: T } | { some: false };
+   ```
+
+2. **No `throw` outside `src/adapters/`.** Return instead:
+   ```ts
+   type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
+   ```
+
+3. **Every match on a union uses `ts-pattern` with `.exhaustive()`.**
+   ```ts
+   import { match } from "ts-pattern";
+   match(result)
+     .with({ ok: true }, (r) => r.value)
+     .with({ ok: false }, (r) => handleError(r.error))
+     .exhaustive();
+   ```
+   Never `.otherwise()` as a shortcut to skip a case — add the missing `.with()`.
+
+4. **No `class` in domain logic.** Use functions and discriminated unions. Classes are allowed only in `src/adapters/` when an external framework requires them.
+
+5. **No `any`, `as unknown as X`, `@ts-ignore`, `@ts-expect-error`, or `!` (non-null assertion).** No exception without a `// sadist-exception: <ticket>` comment.
+
+6. **Cyclomatic complexity ≤ 6, function length ≤ 20 lines, ≤ 3 parameters.** If it doesn't fit, decompose it — don't suppress the rule.
+
+7. **No generic type parameter used only once.** If `<T>` appears in one place, delete it.
+
+8. **Primitive IDs use branded types, never bare `string`/`number`.**
+   ```ts
+   type UserId = string & { readonly __brand: "UserId" };
+   ```
+
+## Before writing any function
+
+Check: does this function throw, return null, use `any`, or exceed 20 lines? If yes, restructure before writing, not after the gate rejects it.
+
+## When the gate rejects a commit
+
+Read the `tsc`/ESLint error verbatim — it names the exact rule and location. Fix that, re-run `tsc --noEmit && eslint .` locally, don't guess and recommit blind.
+
+## Scope
+
+This gate catches structural bugs (null handling, unhandled cases, exceptions, unsafe casts). It does not catch business-logic errors — correct types with wrong logic still pass. Test logic separately.
+
+## Gate coverage
+
+Rules enforced by the ESLint gate (commit-blocking):
+1, 2, 4, 6, 7, 8 — plus `any` and `!` from rule 5.
+
+Rules enforced by convention only (not commit-blocking):
+- Rule 3: `.exhaustive()` on `ts-pattern` matches. The gate cannot detect
+  `.otherwise()` misuse — this is a human-review rule.
+- Rule 5 partial: `@ts-ignore`, `@ts-expect-error`, and `as unknown as X`
+  are not machine-enforced. These require `@typescript-eslint` plugin rules
+  which this gate does not bundle.

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "sadist",
+  "version": "0.1.0",
+  "description": "A merciless TypeScript code quality gate.",
+  "license": "MPL-2.0",
+  "keywords": [
+    "typescript",
+    "eslint",
+    "pre-commit",
+    "code-quality",
+    "strict",
+    "lint"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ElBenjaMasLindo/sadist.git"
+  },
+  "author": "ElBenjaMasLindo",
+  "bugs": {
+    "url": "https://github.com/ElBenjaMasLindo/sadist/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./config/strict": "./dist/config/strict.js"
+  },
+  "files": [
+    "dist",
+    "docs/SKILL.md"
+  ],
+  "peerDependencies": {
+    "typescript": ">=5.4",
+    "eslint": ">=9"
+  },
+  "dependencies": {
+    "ts-pattern": "5.9.0"
+  },
+  "devDependencies": {
+    "husky": "9.1.7",
+    "vitest": "2.1.9",
+    "typescript": "5.6.3",
+    "eslint": "9.39.5",
+    "@typescript-eslint/parser": "8.48.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}