sadist 0.1.0 → 0.2.0

package/README.md

@@ -4,7 +4,7 @@
 [![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.
+A sadistic TypeScript gate that holds your commit hostage until the code is no longer a liability.
 
 `sadist` combines strict `tsc` compilation, exhaustive pattern matching via
 `ts-pattern`, and a small set of architectural ESLint rules into a single

package/bin/sadist.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/cli/index.js");

package/dist/cli/files.d.ts

@@ -0,0 +1,17 @@
+import { type Option, type PkgJson, type Result } from "./types.js";
+export declare function pathExists(rel: string): boolean;
+export declare function readText(rel: string): Result<string, string>;
+export declare function writeText(rel: string, content: string, mode?: number): Result<string, string>;
+export declare function readPkg(): Result<PkgJson, string>;
+export declare function coercePkg(value: unknown): Result<PkgJson, string>;
+export type PkgSeed = {
+    root: Record<string, unknown>;
+    name: string;
+    version: string;
+    scripts: Record<string, unknown>;
+};
+export declare function requireString(v: Record<string, unknown>, key: string): Result<string, string>;
+export declare function requireObject(v: Record<string, unknown>, key: string): Result<Record<string, unknown>, string>;
+export declare function optString(v: unknown): Option<string>;
+export declare function stringRecord(v: unknown): Record<string, string>;
+export declare function hasDep(pkg: PkgJson, name: string): boolean;

package/dist/cli/files.js

@@ -0,0 +1,100 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { ok } from "./types.js";
+export function pathExists(rel) {
+    return existsSync(resolve(process.cwd(), rel));
+}
+export function readText(rel) {
+    try {
+        const content = readFileSync(resolve(process.cwd(), rel), "utf8");
+        return { ok: true, value: content };
+    }
+    catch (e) {
+        return { ok: false, error: `cannot read ${rel}: ${String(e)}` };
+    }
+}
+export function writeText(rel, content, mode) {
+    try {
+        const fullPath = resolve(process.cwd(), rel);
+        mkdirSync(dirname(fullPath), { recursive: true });
+        if (typeof mode === "number") {
+            writeFileSync(fullPath, content, { encoding: "utf8", mode });
+        }
+        else {
+            writeFileSync(fullPath, content, "utf8");
+        }
+        return { ok: true, value: rel };
+    }
+    catch (e) {
+        return { ok: false, error: `cannot write ${rel}: ${String(e)}` };
+    }
+}
+export function readPkg() {
+    const raw = readText("package.json");
+    if (!raw.ok)
+        return raw;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw.value);
+    }
+    catch (e) {
+        return { ok: false, error: `package.json is not valid JSON: ${String(e)}` };
+    }
+    return coercePkg(parsed);
+}
+export function coercePkg(value) {
+    if (typeof value !== "object" || value === null) {
+        return { ok: false, error: "package.json root must be an object" };
+    }
+    const v = value;
+    const name = requireString(v, "name");
+    if (!name.ok)
+        return name;
+    const version = requireString(v, "version");
+    if (!version.ok)
+        return version;
+    const scripts = requireObject(v, "scripts");
+    if (!scripts.ok)
+        return scripts;
+    return ok(buildPkg({ root: v, name: name.value, version: version.value, scripts: scripts.value }));
+}
+function buildPkg(seed) {
+    return {
+        name: seed.name,
+        version: seed.version,
+        type: optString(seed.root["type"]),
+        scripts: stringRecord(seed.scripts),
+        dependencies: stringRecord(seed.root["dependencies"] ?? {}),
+        devDependencies: stringRecord(seed.root["devDependencies"] ?? {}),
+        root: seed.root,
+    };
+}
+export function requireString(v, key) {
+    if (typeof v[key] !== "string") {
+        return { ok: false, error: `package.json missing string '${key}'` };
+    }
+    return { ok: true, value: v[key] };
+}
+export function requireObject(v, key) {
+    const val = v[key];
+    if (typeof val !== "object" || val === null) {
+        return { ok: false, error: `package.json missing '${key}' object` };
+    }
+    return { ok: true, value: val };
+}
+export function optString(v) {
+    return typeof v === "string" ? { some: true, value: v } : { some: false };
+}
+export function stringRecord(v) {
+    if (typeof v !== "object" || v === null)
+        return {};
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+        if (typeof val === "string")
+            out[k] = val;
+    }
+    return out;
+}
+export function hasDep(pkg, name) {
+    return name in pkg.dependencies || name in pkg.devDependencies;
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,51 @@
+import { match, P } from "ts-pattern";
+import { runInstallCommand } from "./install.js";
+const argv = process.argv.slice(2);
+const sub = argv[0] ?? "install";
+const rest = argv.slice(1);
+match(sub)
+    .with("install", () => {
+    runCommand(runInstallCommand(rest));
+})
+    .with("--help", () => {
+    printUsage();
+    process.exit(0);
+})
+    .with("-h", () => {
+    printUsage();
+    process.exit(0);
+})
+    .with(P.string, () => {
+    process.stderr.write(`sadist: unknown command: ${sub}\n`);
+    printUsage();
+    process.exit(1);
+})
+    .exhaustive();
+function runCommand(r) {
+    match(r)
+        .with({ ok: true }, (v) => {
+        process.stdout.write(`sadist: ${v.value}\n`);
+        process.exit(0);
+    })
+        .with({ ok: false }, (e) => {
+        process.stderr.write(`sadist: error: ${e.error}\n`);
+        process.exit(1);
+    })
+        .exhaustive();
+}
+function printUsage() {
+    process.stdout.write([
+        "sadist - A sadistic TypeScript gate that holds your commit hostage until the code is no longer a liability.",
+        "",
+        "usage:",
+        "  sadist install [flags]    configure a project with the gate",
+        "  sadist --help             show this help",
+        "",
+        "flags:",
+        "  --no-husky     skip pre-commit hook setup",
+        "  --no-tsconfig  skip tsconfig.json creation",
+        "  --force        overwrite existing files",
+        "  --dry-run      print plan without applying changes",
+        "",
+    ].join("\n"));
+}

package/dist/cli/install.d.ts

@@ -0,0 +1,8 @@
+import type { InstallFlags, InstallPlan, PkgJson, Result } from "./types.js";
+export declare function buildPlan(pkg: PkgJson, flags: InstallFlags): Result<InstallPlan, string>;
+export declare function printPlan(plan: InstallPlan): void;
+export declare function installMissing(plan: InstallPlan, flags: InstallFlags): Result<string, string>;
+export declare function applyConfigs(flags: InstallFlags, force: boolean): Result<string, string>;
+export declare function applyPackageJson(pkg: PkgJson, flags: InstallFlags): Result<string, string>;
+export declare function applyHusky(flags: InstallFlags, pkgManager?: "pnpm" | "yarn" | "npm"): Result<string, string>;
+export declare function runInstallCommand(argv: readonly string[]): Result<string, string>;

package/dist/cli/install.js

@@ -0,0 +1,297 @@
+import { match, P } from "ts-pattern";
+import { hasDep, pathExists, readPkg, writeText, } from "./files.js";
+import { addCmd, detectPkgManager, exec, isGitRepo } from "./process.js";
+import { eslintConfigTemplate, gitignoreTemplate, preCommitTemplate, tsconfigTemplate, } from "./templates.js";
+const LAX_SCRIPT = "eslint . && tsc --noEmit";
+const PREPARE_SCRIPT = "husky";
+export function buildPlan(pkg, flags) {
+    const pkgManager = detectPkgManager();
+    const missing = computeMissing(pkg, flags);
+    const out = emptyOut();
+    collectPlans(pkg, flags, out);
+    return ok({
+        pkgManager,
+        missing,
+        willCreate: out.create,
+        willWarn: out.warn,
+    });
+}
+function emptyOut() {
+    return { create: [], warn: [] };
+}
+function collectPlans(pkg, flags, out) {
+    planEslint(out);
+    planTsconfig(flags, out);
+    planLaxScript(pkg, out);
+    planModuleType(pkg, out);
+    planHusky(flags, pkg, out);
+    planGitignore(out);
+}
+function planEslint(out) {
+    if (!pathExists("eslint.config.mjs")) {
+        out.create.push("eslint.config.mjs");
+        return;
+    }
+    out.warn.push("eslint.config.mjs already exists; add 'import strict from \"sadist/config/strict\"' and spread ...strict manually");
+}
+function planTsconfig(flags, out) {
+    if (flags.noTsconfig)
+        return;
+    if (!pathExists("tsconfig.json")) {
+        out.create.push("tsconfig.json");
+        return;
+    }
+    out.warn.push("tsconfig.json already exists; ensure strict, noUncheckedIndexedAccess, exactOptionalPropertyTypes are enabled");
+}
+function planLaxScript(pkg, out) {
+    const current = pkg.scripts["lax"];
+    if (!current) {
+        out.create.push("package.json#scripts.lax");
+        return;
+    }
+    if (current !== LAX_SCRIPT) {
+        out.warn.push(`package.json#scripts.lax exists with value "${current}"; expected "${LAX_SCRIPT}"`);
+    }
+}
+function planModuleType(pkg, out) {
+    if (pkg.type.some === false) {
+        out.warn.push("package.json missing \"type\": \"module\"");
+        return;
+    }
+    if (pkg.type.value !== "module") {
+        out.warn.push(`package.json#type is "${pkg.type.value}"; expected "module"`);
+    }
+}
+function planHusky(flags, pkg, out) {
+    if (flags.noHusky)
+        return;
+    if (!pathExists(".husky/pre-commit")) {
+        out.create.push(".husky/pre-commit");
+    }
+    else {
+        out.warn.push(".husky/pre-commit already exists");
+    }
+    const prep = pkg.scripts["prepare"];
+    if (!prep) {
+        out.create.push("package.json#scripts.prepare");
+    }
+    else if (prep !== PREPARE_SCRIPT) {
+        out.warn.push(`package.json#scripts.prepare is "${prep}"; expected "${PREPARE_SCRIPT}"`);
+    }
+}
+function planGitignore(out) {
+    if (!pathExists(".gitignore")) {
+        out.create.push(".gitignore");
+        return;
+    }
+    out.warn.push(".gitignore already exists; review recommended entries");
+}
+export function printPlan(plan) {
+    process.stdout.write(`\n[plan] package manager: ${plan.pkgManager}\n`);
+    printSection("install", plan.missing, formatDep);
+    printSection("create", plan.willCreate, formatCreate);
+    printSection("warn", plan.willWarn, formatWarn);
+    process.stdout.write("\n");
+}
+function printSection(label, items, fmt) {
+    if (items.length === 0) {
+        process.stdout.write(`[plan] ${label}: (none)\n`);
+        return;
+    }
+    process.stdout.write(`[plan] ${label}:\n`);
+    for (const it of items)
+        process.stdout.write(`  ${fmt(it)}\n`);
+}
+function formatDep(d) {
+    return `- ${d.name} (${d.class}) ${d.range}`;
+}
+function formatCreate(f) {
+    return `+ ${f}`;
+}
+function formatWarn(w) {
+    return `! ${w}`;
+}
+export function installMissing(plan, flags) {
+    if (flags.dryRun)
+        return { ok: true, value: "dry-run" };
+    return installByClass(plan.pkgManager, plan.missing);
+}
+function installByClass(pkg, missing) {
+    const r1 = runClass(pkg, missing, "dev");
+    if (!r1.ok)
+        return r1;
+    return runClass(pkg, missing, "prod");
+}
+function runClass(pkg, missing, klass) {
+    const deps = missing.filter((d) => d.class === klass).map((d) => `${d.name}@${d.range}`);
+    if (deps.length === 0)
+        return { ok: true, value: "noop" };
+    const [cmd, args] = addCmd(pkg, klass, deps);
+    return exec(cmd, args);
+}
+export function applyConfigs(flags, force) {
+    if (flags.dryRun)
+        return { ok: true, value: "dry-run" };
+    return writeAllConfigs({ flags, force });
+}
+function writeAllConfigs(ctx) {
+    const r1 = maybeWrite(ctx, "tsconfig.json", tsconfigTemplate);
+    if (!r1.ok)
+        return r1;
+    const r2 = maybeWrite(ctx, "eslint.config.mjs", eslintConfigTemplate);
+    if (!r2.ok)
+        return r2;
+    return maybeWrite(ctx, ".gitignore", gitignoreTemplate);
+}
+function maybeWrite(ctx, file, content) {
+    return match(mustWrite(ctx, file))
+        .with(true, () => writeText(file, content))
+        .with(false, () => ok("skip"))
+        .exhaustive();
+}
+function mustWrite(ctx, file) {
+    if (ctx.flags.noTsconfig && file === "tsconfig.json")
+        return false;
+    return ctx.force || !pathExists(file);
+}
+export function applyPackageJson(pkg, flags) {
+    if (flags.dryRun)
+        return { ok: true, value: "dry-run" };
+    const currentPkgR = readPkg();
+    if (!currentPkgR.ok)
+        return currentPkgR;
+    const next = buildNextPkg(currentPkgR.value, flags);
+    const json = `${JSON.stringify(next, null, 2)}\n`;
+    return writeText("package.json", json);
+}
+function buildNextPkg(pkg, flags) {
+    const scripts = mergeScripts(pkg, flags);
+    return {
+        ...pkg.root,
+        type: pkg.type.some ? pkg.type.value : "module",
+        scripts,
+    };
+}
+function mergeScripts(pkg, flags) {
+    const scripts = { ...pkg.scripts };
+    if (!scripts["lax"])
+        scripts["lax"] = LAX_SCRIPT;
+    if (!flags.noHusky && !scripts["prepare"]) {
+        scripts["prepare"] = PREPARE_SCRIPT;
+    }
+    return scripts;
+}
+export function applyHusky(flags, pkgManager = "npm") {
+    if (flags.noHusky)
+        return { ok: true, value: "skipped" };
+    if (flags.dryRun)
+        return { ok: true, value: "dry-run" };
+    return writeHuskyHook(pkgManager);
+}
+function writeHuskyHook(pkgManager) {
+    if (!isGitRepo()) {
+        return { ok: false, error: ".git not found; init a repo before husky" };
+    }
+    if (!pathExists(".husky/pre-commit")) {
+        const r = writeText(".husky/pre-commit", preCommitTemplate(pkgManager), 0o755);
+        if (!r.ok)
+            return r;
+    }
+    return { ok: true, value: "husky" };
+}
+export function runInstallCommand(argv) {
+    const flags = parseFlags(argv);
+    if (!flags.ok)
+        return flags;
+    return runWith(flags.value);
+}
+function runWith(flags) {
+    const pkgR = readPkg();
+    if (!pkgR.ok)
+        return pkgR;
+    const planR = buildPlan(pkgR.value, flags);
+    if (!planR.ok)
+        return planR;
+    printPlan(planR.value);
+    return executeSteps(pkgR.value, planR.value, flags);
+}
+function executeSteps(pkg, plan, flags) {
+    const steps = [
+        () => installMissing(plan, flags),
+        () => applyPackageJson(pkg, flags),
+        () => applyConfigs(flags, flags.force),
+        () => applyHusky(flags, plan.pkgManager),
+    ];
+    for (const step of steps) {
+        const r = step();
+        if (!r.ok)
+            return r;
+    }
+    return { ok: true, value: "done" };
+}
+function computeMissing(pkg, flags) {
+    const required = [
+        { name: "sadist", class: "dev", range: "0.1.0" },
+        { name: "typescript", class: "dev", range: "5.6.3" },
+        { name: "eslint", class: "dev", range: "9.39.5" },
+        { name: "@typescript-eslint/parser", class: "dev", range: "8.48.1" },
+        { name: "ts-pattern", class: "prod", range: "5.9.0" },
+        ...(flags.noHusky
+            ? []
+            : [{ name: "husky", class: "dev", range: "9.1.7" }]),
+    ];
+    return required.filter((d) => !hasDep(pkg, d.name));
+}
+function parseFlags(argv) {
+    const flags = {
+        noHusky: false,
+        noTsconfig: false,
+        force: false,
+        dryRun: false,
+    };
+    for (const a of argv) {
+        const r = parseOne(a, flags);
+        if (!r.ok)
+            return r;
+    }
+    return { ok: true, value: flags };
+}
+function parseOne(flag, flags) {
+    return match(flag)
+        .with("--no-husky", () => okMut(flags, "noHusky"))
+        .with("--no-tsconfig", () => okMut(flags, "noTsconfig"))
+        .with("--force", () => okMut(flags, "force"))
+        .with("--dry-run", () => okMut(flags, "dryRun"))
+        .with("--help", () => {
+        printHelp();
+        process.exit(0);
+        return ok(flags);
+    })
+        .with(P.string, (f) => ({
+        ok: false,
+        error: `unknown flag: ${f}`,
+    }))
+        .exhaustive();
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function okMut(flags, key) {
+    flags[key] = true;
+    return { ok: true, value: flags };
+}
+function printHelp() {
+    process.stdout.write([
+        "sadist install - configure a project with the sadist gate",
+        "",
+        "usage: sadist install [flags]",
+        "",
+        "flags:",
+        "  --no-husky     skip pre-commit hook setup",
+        "  --no-tsconfig  skip tsconfig.json creation",
+        "  --force        overwrite existing files",
+        "  --dry-run      print plan without applying changes",
+        "  --help         show this help",
+        "",
+    ].join("\n"));
+}

package/dist/cli/process.d.ts

@@ -0,0 +1,5 @@
+import type { PkgManager, Result } from "./types.js";
+export declare function detectPkgManager(): PkgManager;
+export declare function exec(cmd: string, args: readonly string[]): Result<string, string>;
+export declare function addCmd(pkg: PkgManager, klass: "dev" | "prod", deps: readonly string[]): readonly [string, string[]];
+export declare function isGitRepo(): boolean;

package/dist/cli/process.js

@@ -0,0 +1,42 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathExists } from "./files.js";
+export function detectPkgManager() {
+    if (pathExists("pnpm-lock.yaml"))
+        return "pnpm";
+    if (pathExists("yarn.lock"))
+        return "yarn";
+    return "npm";
+}
+export function exec(cmd, args) {
+    const r = spawnSync(cmd, args, {
+        cwd: process.cwd(),
+        stdio: "inherit",
+        encoding: "utf8",
+    });
+    if (r.status !== 0) {
+        return {
+            ok: false,
+            error: `${cmd} ${args.join(" ")} exited with code ${String(r.status)}`,
+        };
+    }
+    return { ok: true, value: "" };
+}
+export function addCmd(pkg, klass, deps) {
+    if (pkg === "pnpm") {
+        const args = klass === "dev" ? ["add", "-D", ...deps] : ["add", ...deps];
+        return ["pnpm", args];
+    }
+    if (pkg === "yarn") {
+        const args = klass === "dev" ? ["add", "-D", ...deps] : ["add", ...deps];
+        return ["yarn", args];
+    }
+    const args = klass === "dev"
+        ? ["install", "--save-dev", ...deps]
+        : ["install", "--save", ...deps];
+    return ["npm", args];
+}
+export function isGitRepo() {
+    return existsSync(resolve(process.cwd(), ".git"));
+}

package/dist/cli/templates.d.ts

@@ -0,0 +1,4 @@
+export declare const eslintConfigTemplate = "import strict from \"sadist/config/strict\";\nimport tsParser from \"@typescript-eslint/parser\";\n\nexport default [\n  ...strict,\n  {\n    files: [\"src/**/*.ts\"],\n    languageOptions: {\n      parser: tsParser,\n    },\n  },\n];\n";
+export declare const tsconfigTemplate = "{\n  \"compilerOptions\": {\n    \"strict\": true,\n    \"noUncheckedIndexedAccess\": true,\n    \"exactOptionalPropertyTypes\": true,\n    \"noImplicitOverride\": true,\n    \"noPropertyAccessFromIndexSignature\": true,\n    \"target\": \"ES2022\",\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"declaration\": true,\n    \"skipLibCheck\": true\n  },\n  \"include\": [\"src\"]\n}\n";
+export declare function preCommitTemplate(pkgManager?: "pnpm" | "yarn" | "npm"): string;
+export declare const gitignoreTemplate = "# dependencies\nnode_modules/\n.pnpm-store/\n\n# build output\ndist/\n\n# environment\n.env\n.env.*\n\n# editor\n.vscode/\n.idea/\n.zed/\n\n# os\n.DS_Store\nThumbs.db\n";

package/dist/cli/templates.js

@@ -0,0 +1,56 @@
+export const eslintConfigTemplate = `import strict from "sadist/config/strict";
+import tsParser from "@typescript-eslint/parser";
+
+export default [
+  ...strict,
+  {
+    files: ["src/**/*.ts"],
+    languageOptions: {
+      parser: tsParser,
+    },
+  },
+];
+`;
+export const tsconfigTemplate = `{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`;
+export function preCommitTemplate(pkgManager = "npm") {
+    if (pkgManager === "pnpm")
+        return "pnpm run lax\n";
+    if (pkgManager === "yarn")
+        return "yarn lax\n";
+    return "npm run lax\n";
+}
+export const gitignoreTemplate = `# dependencies
+node_modules/
+.pnpm-store/
+
+# build output
+dist/
+
+# environment
+.env
+.env.*
+
+# editor
+.vscode/
+.idea/
+.zed/
+
+# os
+.DS_Store
+Thumbs.db
+`;

package/dist/cli/types.d.ts

@@ -0,0 +1,49 @@
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function ok<T>(value: T): {
+    ok: true;
+    value: T;
+};
+export declare function err<E>(error: E): {
+    ok: false;
+    error: E;
+};
+export type Option<T> = {
+    some: true;
+    value: T;
+} | {
+    some: false;
+};
+export type PkgManager = "pnpm" | "yarn" | "npm";
+export type InstallFlags = {
+    readonly noHusky: boolean;
+    readonly noTsconfig: boolean;
+    readonly force: boolean;
+    readonly dryRun: boolean;
+};
+export type PkgJson = {
+    readonly name: string;
+    readonly version: string;
+    readonly type: Option<string>;
+    readonly scripts: Readonly<Record<string, string>>;
+    readonly dependencies: Readonly<Record<string, string>>;
+    readonly devDependencies: Readonly<Record<string, string>>;
+    readonly root: Readonly<Record<string, unknown>>;
+};
+export type DepClass = "dev" | "prod";
+export type MissingDep = {
+    readonly name: string;
+    readonly class: DepClass;
+    readonly range: string;
+};
+export type InstallPlan = {
+    readonly pkgManager: PkgManager;
+    readonly missing: readonly MissingDep[];
+    readonly willCreate: readonly string[];
+    readonly willWarn: readonly string[];
+};

package/dist/cli/types.js

@@ -0,0 +1,6 @@
+export function ok(value) {
+    return { ok: true, value };
+}
+export function err(error) {
+    return { ok: false, error };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sadist",
-  "version": "0.1.0",
-  "description": "A merciless TypeScript code quality gate.",
+  "version": "0.2.0",
+  "description": "A sadistic TypeScript gate that holds your commit hostage until the code is no longer a liability.",
   "license": "MPL-2.0",
   "keywords": [
     "typescript",
@@ -9,6 +9,7 @@
     "pre-commit",
     "code-quality",
     "strict",
+    "gate",
     "lint"
   ],
   "repository": {
@@ -22,12 +23,16 @@
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "sadist": "./bin/sadist.js"
+  },
   "exports": {
     ".": "./dist/index.js",
     "./config/strict": "./dist/config/strict.js"
   },
   "files": [
     "dist",
+    "bin",
     "docs/SKILL.md"
   ],
   "peerDependencies": {
@@ -42,7 +47,8 @@
     "vitest": "2.1.9",
     "typescript": "5.6.3",
     "eslint": "9.39.5",
-    "@typescript-eslint/parser": "8.48.1"
+    "@typescript-eslint/parser": "8.48.1",
+    "@types/node": "24.13.3"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",