typescript-bedrock 0.1.6 → 0.1.9

package/README.md

@@ -14,6 +14,7 @@ Shared tooling for strict Bun and TypeScript 7 repos. It holds the configs each
 | Command | Does |
 | --- | --- |
 | `typescript-bedrock adopt <target>` | Set up a repo. `--help` lists the options. |
+| `typescript-bedrock lint [oxlint args]` | Run oxlint. A type-aware run takes the lock `/tmp/typescript-bedrock-lint.lock`, so one runs at a time on the machine and a second one prints that it waits |
 | `typescript-bedrock guard` | Fail on suppression comments, other package managers, TypeScript drift, unsorted catalogs, package API without JSDoc, and files that differ from what `adopt` writes |
 
 `adopt` writes `.just/typescript.just` and `.github/workflows/typescript.yml` beside the files every bedrock shares (`files/base`, a copy of `base/`). Git hooks, Markdown linting, and `AGENTS.md` come from the shared part; `just setup` points git at `.githooks`. `adopt` upserts its own `typescript-bedrock` block in `AGENTS.md`, `.gitignore`, `.gitattributes`, `.editorconfig`, and `.github/dependabot.yml` and keeps the rest of each file. It keeps every file it replaces or removes as `<file>.bak`, and a second `adopt` plans nothing.

package/files/.github/workflows/typescript.yml

@@ -3,7 +3,7 @@ name: TypeScript
 
 on:
   push:
-    branches: [main]
+    branches: [main, master]
   pull_request:
 
 permissions:

package/files/.just/typescript.just

@@ -19,13 +19,13 @@ format-check:
 typecheck:
     bun check
 
-# Run oxlint. The base justfile lints Markdown.
+# Run oxlint, one type-aware run at a time on the machine. The base justfile lints Markdown.
 lint:
-    bun run oxlint
+    bun run typescript-bedrock lint
 
 # Apply oxlint's fixes.
 lint-fix:
-    bun run oxlint --fix
+    bun run typescript-bedrock lint --fix
 
 # Run the tests.
 test:

package/files/base/.github/workflows/base.yml

@@ -2,7 +2,7 @@ name: Base
 
 on:
   push:
-    branches: [main]
+    branches: [main, master]
   pull_request:
 
 permissions:

package/files/base/justfile

@@ -10,10 +10,11 @@ mod? rust ".just/rust.just"
 mod? swift ".just/swift.just"
 mod? cpp ".just/cpp.just"
 mod? jvm ".just/jvm.just"
+mod? go ".just/go.just"
 
 import? "project.just"
 
-languages := "typescript rust swift cpp jvm"
+languages := "typescript rust swift cpp jvm go"
 
 # List the recipes.
 default:

package/oxlintrc.json

@@ -36,6 +36,15 @@
 			}
 		],
 		"typescript/dot-notation": "error",
+		"typescript/no-misused-promises": [
+			"error",
+			{
+				"checksVoidReturn": {
+					"arguments": false
+				}
+			}
+		],
+		"typescript/strict-void-return": "off",
 		"typescript/prefer-readonly-parameter-types": "off",
 		"eslint/arrow-body-style": ["error", "as-needed"],
 		"eslint/grouped-accessor-pairs": "error",
@@ -133,7 +142,12 @@
 		"typescript/prefer-return-this-type": "error",
 		"typescript/prefer-string-starts-ends-with": "error",
 		"typescript/unified-signatures": "error",
-		"unicorn/catch-error-name": "error",
+		"unicorn/catch-error-name": [
+			"error",
+			{
+				"ignore": ["^_?\\$$"]
+			}
+		],
 		"unicorn/consistent-date-clone": "error",
 		"unicorn/consistent-existence-index-check": "error",
 		"unicorn/error-message": "error",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typescript-bedrock",
-	"version": "0.1.6",
+	"version": "0.1.9",
 	"description": "Strictest Bun + TypeScript 7 tooling: shared configs, git hooks, a guard, and an adopt command.",
 	"license": "MIT",
 	"author": "xsyetopz",

package/src/adopt/rewrite-script.ts

@@ -60,11 +60,11 @@ const TOOLS: ReadonlyMap<string, (args: Tokens) => Tokens> = new Map<
 		([sub = "", ...args]) =>
 			sub === "format"
 				? ["bun", "fmt", ...(args.includes("--write") ? [] : ["--check"])]
-				: ["oxlint", ...withFix(args)],
+				: ["typescript-bedrock", "lint", ...withFix(args)],
 	],
 	["cross-env", (args) => rewriteCommand(args)],
 	["esno", runOnBun],
-	["eslint", (args) => ["oxlint", ...withFix(args)]],
+	["eslint", (args) => ["typescript-bedrock", "lint", ...withFix(args)]],
 	["jest", (args) => ["bun", "test", ...args]],
 	["node", runOnBun],
 	["npm", (args) => packageManager("npm", args)],

package/src/adopt/template.ts

@@ -8,9 +8,9 @@ const SCRIPTS = {
 	format: "bun fmt",
 	"format:check": "bun fmt --check",
 	guard: "typescript-bedrock guard",
-	lint: "bun run --sequential --no-exit-on-error oxlint markdownlint-cli2",
+	lint: "bun run --sequential --no-exit-on-error 'typescript-bedrock lint' markdownlint-cli2",
 	"lint:fix":
-		"bun run --sequential --no-exit-on-error 'oxlint --fix' 'markdownlint-cli2 --fix'",
+		"bun run --sequential --no-exit-on-error 'typescript-bedrock lint --fix' 'markdownlint-cli2 --fix'",
 	test: "bun test --pass-with-no-tests",
 	typecheck: "bun check",
 	verify: "bun run --sequential format:check typecheck lint guard test",

package/src/cli.ts

@@ -1,11 +1,14 @@
 #!/usr/bin/env bun
 import { adopt } from "./adopt/command.ts";
 import { guard } from "./guard.ts";
+import { lint } from "./lint.ts";
 
 const USAGE = `Usage: typescript-bedrock <command> [args]
 
 Commands:
   adopt <target>     Set up a repo with typescript-bedrock. See \`adopt --help\`.
+  lint [oxlint args] Run oxlint. A type-aware run waits for the machine-wide lock,
+                     so one runs at a time on this machine.
   guard              Report suppression comments, foreign lockfiles and scripts,
                      TypeScript drift, and unsorted catalogs, and files that differ
                      from what adopt writes.`;
@@ -13,6 +16,7 @@ Commands:
 const COMMANDS: Record<string, (args: string[]) => Promise<number>> = {
 	adopt,
 	guard: () => guard(process.cwd()),
+	lint,
 };
 
 const [name = "", ...args] = Bun.argv.slice(2);

package/src/lint.ts

@@ -0,0 +1,138 @@
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** Flags that print information and lint nothing, so they need no lock. */
+const QUERY_FLAGS = new Set([
+	"-h",
+	"--help",
+	"-V",
+	"--version",
+	"--rules",
+	"--print-config",
+	"--init",
+	"--lsp",
+]);
+
+const POLL_MS = 500;
+/** A path every user and sandbox on the machine sees, so all runs share one lock. */
+const LOCK_ROOT = process.platform === "win32" ? tmpdir() : "/tmp";
+
+/** The directory that holds the machine-wide type-aware lint lock. */
+export const LOCK_PATH = join(LOCK_ROOT, "typescript-bedrock-lint.lock");
+
+/** Options of {@link withLock}. */
+export interface LockOptions {
+	/** Receives the line that says why the run waits; prints to stderr by default. */
+	onWait?: (message: string) => void;
+	/** Milliseconds between two tries; 500 by default. */
+	pollMs?: number;
+}
+
+/**
+ * Whether oxlint runs type-aware rules for these arguments. The shared config
+ * turns `typeAware` on, so every run lints with tsgolint except a query.
+ */
+export const isTypeAware = (args: readonly string[]): boolean =>
+	!args.some((arg) => QUERY_FLAGS.has(arg));
+
+const ownerOf = async (path: string): Promise<number | undefined> => {
+	const text = await Bun.file(join(path, "pid"))
+		.text()
+		.catch(() => "");
+	const pid = Number(text);
+	return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+};
+
+const isAlive = (pid: number): boolean => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		// EPERM means the process exists and belongs to another user.
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+};
+
+const isExists = (error: unknown): boolean =>
+	error instanceof Error && "code" in error && error.code === "EEXIST";
+
+/** Takes the lock, or returns the pid that holds it. */
+const tryAcquire = async (path: string): Promise<number | undefined> => {
+	try {
+		await mkdir(path);
+	} catch (error) {
+		if (!isExists(error)) {
+			throw error;
+		}
+		const owner = await ownerOf(path);
+		if (owner !== undefined && !isAlive(owner)) {
+			await rm(path, { recursive: true, force: true });
+			return tryAcquire(path);
+		}
+		return owner ?? 0;
+	}
+	await Bun.write(join(path, "pid"), String(process.pid));
+	return undefined;
+};
+
+/**
+ * Runs `task` while holding the lock at `path`. A second caller waits, prints
+ * that it waits, and runs once the first finishes; a lock whose owner is gone
+ * is broken.
+ */
+export const withLock = async <T>(
+	path: string,
+	task: () => Promise<T>,
+	{ onWait = console.error, pollMs = POLL_MS }: LockOptions = {},
+): Promise<T> => {
+	const acquire = async (announced: boolean): Promise<void> => {
+		const holder = await tryAcquire(path);
+		if (holder === undefined) {
+			return;
+		}
+		if (!announced) {
+			onWait(
+				`typescript-bedrock: waiting for the type-aware lint that process ${holder} runs; one runs at a time on this machine.`,
+			);
+		}
+		await Bun.sleep(pollMs);
+		return acquire(true);
+	};
+	await acquire(false);
+	try {
+		return await task();
+	} finally {
+		await rm(path, { recursive: true, force: true });
+	}
+};
+
+const oxlintBin = (): string =>
+	join(
+		dirname(fileURLToPath(import.meta.resolve("oxlint/package.json"))),
+		"bin/oxlint",
+	);
+
+const runOxlint = (args: readonly string[]): Promise<number> => {
+	const child = Bun.spawn(["bun", oxlintBin(), ...args], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	const stop = () => {
+		child.kill();
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	return child.exited;
+};
+
+/**
+ * Runs oxlint with `args`. A type-aware run takes the machine-wide lock first,
+ * because each one loads a whole TypeScript program into memory.
+ */
+export const lint = (args: readonly string[]): Promise<number> =>
+	isTypeAware(args)
+		? withLock(LOCK_PATH, () => runOxlint(args))
+		: runOxlint(args);