adamantite 0.41.0 → 0.42.0

package/dist/presets/lint/plugin/rules/no-overzealous-destructuring.js

@@ -0,0 +1,92 @@
+import { readPositiveIntegerOption } from "../options.js";
+//#region presets/lint/plugin/rules/no-overzealous-destructuring.ts
+/**
+* `const { data: { user } } = query` nests two patterns, which stays allowed.
+*/
+const DEFAULT_MAX_DEPTH = 2;
+/**
+* Five properties cover typical component props. A rest element does not count.
+*/
+const DEFAULT_MAX_PROPERTIES = 5;
+function isPattern(node) {
+	return node.type === "ObjectPattern" || node.type === "ArrayPattern";
+}
+/**
+* The pattern that directly contains `pattern`, through a property, a default value, or a rest
+* element. A root pattern, such as a declaration target or a parameter, has none.
+*/
+function getParentPattern(pattern) {
+	let node = pattern.parent;
+	while (node.type === "AssignmentPattern" || node.type === "RestElement") node = node.parent;
+	if (node.type === "Property" && node.parent.type === "ObjectPattern") return node.parent;
+	return isPattern(node) ? node : void 0;
+}
+function getDepth(pattern) {
+	let depth = 1;
+	let parent = getParentPattern(pattern);
+	while (parent !== void 0) {
+		depth += 1;
+		parent = getParentPattern(parent);
+	}
+	return depth;
+}
+const rule = {
+	create(context) {
+		const maxDepth = readPositiveIntegerOption(context.options, "maxDepth") ?? DEFAULT_MAX_DEPTH;
+		const maxProperties = readPositiveIntegerOption(context.options, "maxProperties") ?? DEFAULT_MAX_PROPERTIES;
+		function checkDepth(node) {
+			const depth = getDepth(node);
+			if (depth === maxDepth + 1) context.report({
+				data: {
+					depth: String(depth),
+					maxDepth: String(maxDepth)
+				},
+				messageId: "tooDeep",
+				node
+			});
+		}
+		return {
+			ArrayPattern: checkDepth,
+			ObjectPattern(node) {
+				checkDepth(node);
+				const count = node.properties.filter((property) => property.type === "Property").length;
+				if (count > maxProperties) context.report({
+					data: {
+						count: String(count),
+						maxProperties: String(maxProperties)
+					},
+					messageId: "tooManyProperties",
+					node
+				});
+			}
+		};
+	},
+	meta: {
+		defaultOptions: [{
+			maxDepth: DEFAULT_MAX_DEPTH,
+			maxProperties: DEFAULT_MAX_PROPERTIES
+		}],
+		docs: { description: "Disallow destructuring patterns that nest too deep or take too many properties from one object." },
+		messages: {
+			tooDeep: "This destructuring pattern is nested {{depth}} levels deep. The limit is {{maxDepth}}. Keep the outer object and read its members, or split the pattern into separate declarations.",
+			tooManyProperties: "This destructuring pattern takes {{count}} properties from one object. The limit is {{maxProperties}}. Keep the object and read its members where you use them, or split the pattern."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				maxDepth: {
+					minimum: 1,
+					type: "integer"
+				},
+				maxProperties: {
+					minimum: 1,
+					type: "integer"
+				}
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+};
+//#endregion
+export { rule as default };

package/dist/presets/lint/plugin/rules/no-react-state-hooks.d.ts

@@ -0,0 +1,10 @@
+import { Rule } from "@oxlint/plugins";
+//#region presets/lint/plugin/rules/no-react-state-hooks.d.ts
+/**
+ * Convert a glob to a regular expression that matches a whole path with forward slashes. Supports
+ * `**`, `*`, `?`, `[a-z]` and `[!a-z]` character classes, and `{a,b}` alternation.
+ */
+declare function globToRegExp(glob: string): RegExp;
+declare const rule: Rule;
+//#endregion
+export { rule as default, globToRegExp };

package/dist/presets/lint/plugin/rules/no-react-state-hooks.js

@@ -0,0 +1,160 @@
+import { readStringArrayOption } from "../options.js";
+//#region presets/lint/plugin/rules/no-react-state-hooks.ts
+const HOOK_MESSAGES = /* @__PURE__ */ new Map([
+	["useCallback", "memoization"],
+	["useEffect", "effect"],
+	["useLayoutEffect", "effect"],
+	["useMemo", "memoization"],
+	["useReducer", "localState"],
+	["useState", "localState"],
+	["useSyncExternalStore", "externalStore"]
+]);
+const DEFAULT_HOOKS = [...HOOK_MESSAGES.keys()];
+/**
+* Modules where hooks are permitted: hook modules such as `useCart.ts` or `use-cart.ts`, and
+* everything under a `hooks` directory. Everything else is feature code, including files such as
+* `userProfile.tsx`.
+*/
+const DEFAULT_ALLOW = [
+	"**/use[A-Z]*.{ts,tsx}",
+	"**/use-*.{ts,tsx}",
+	"**/hooks/**"
+];
+const REACT_MODULE = "react";
+function escapeRegExp(text) {
+	return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+}
+/**
+* Convert a glob to a regular expression that matches a whole path with forward slashes. Supports
+* `**`, `*`, `?`, `[a-z]` and `[!a-z]` character classes, and `{a,b}` alternation.
+*/
+function globToRegExp(glob) {
+	let source = "";
+	let index = 0;
+	while (index < glob.length) {
+		const rest = glob.slice(index);
+		if (rest.startsWith("**/")) {
+			source += "(?:.*/)?";
+			index += 3;
+		} else if (rest === "/**") {
+			source += "(?:/.*)?";
+			index += 3;
+		} else if (rest.startsWith("**")) {
+			source += ".*";
+			index += 2;
+		} else if (rest.startsWith("*")) {
+			source += "[^/]*";
+			index += 1;
+		} else if (rest.startsWith("?")) {
+			source += "[^/]";
+			index += 1;
+		} else if (rest.startsWith("[") && rest.indexOf("]") > 1) {
+			const end = rest.indexOf("]");
+			const negated = rest.startsWith("[!");
+			const characters = rest.slice(negated ? 2 : 1, end).replaceAll(/[\\^]/g, String.raw`\$&`);
+			source += `[${negated ? "^" : ""}${characters}]`;
+			index += end + 1;
+		} else if (rest.startsWith("{") && rest.includes("}")) {
+			const end = rest.indexOf("}");
+			const alternatives = rest.slice(1, end).split(",").map((alternative) => escapeRegExp(alternative));
+			source += `(?:${alternatives.join("|")})`;
+			index += end + 1;
+		} else {
+			source += escapeRegExp(glob.charAt(index));
+			index += 1;
+		}
+	}
+	return new RegExp(`^${source}$`);
+}
+function toPosixPath(path) {
+	return path.replaceAll("\\", "/");
+}
+/**
+* The path that `allow` globs match: relative to the working directory when the file is inside it,
+* and absolute otherwise.
+*/
+function getMatchPath(context) {
+	const filename = toPosixPath(context.filename);
+	const cwd = toPosixPath(context.cwd).replace(/\/$/, "");
+	return filename.startsWith(`${cwd}/`) ? filename.slice(cwd.length + 1) : filename;
+}
+function getImportedName(specifier) {
+	return specifier.imported.type === "Literal" ? specifier.imported.value : specifier.imported.name;
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+function getPropertyName(member) {
+	if (!member.computed) return member.property.type === "Identifier" ? member.property.name : void 0;
+	return isStringLiteral(member.property) ? member.property.value : void 0;
+}
+function isCallee(node) {
+	const { parent } = node;
+	return parent?.type === "CallExpression" && parent.callee === node;
+}
+const rule = {
+	create(context) {
+		const hooks = new Set(readStringArrayOption(context.options, "hooks") ?? DEFAULT_HOOKS);
+		const allow = (readStringArrayOption(context.options, "allow") ?? DEFAULT_ALLOW).map((glob) => globToRegExp(glob));
+		const matchPath = getMatchPath(context);
+		if (allow.some((pattern) => pattern.test(matchPath))) return {};
+		function report(node, hook) {
+			context.report({
+				data: { hook },
+				messageId: HOOK_MESSAGES.get(hook) ?? "banned",
+				node
+			});
+		}
+		function getReferences(specifier) {
+			return context.sourceCode.getDeclaredVariables(specifier).flatMap((variable) => variable.references).map((reference) => reference.identifier);
+		}
+		return { ImportDeclaration(node) {
+			if (node.source.value !== REACT_MODULE || node.importKind === "type") return;
+			for (const specifier of node.specifiers) {
+				if (specifier.type === "ImportSpecifier") {
+					const hook = getImportedName(specifier);
+					if (specifier.importKind === "type" || !hooks.has(hook)) continue;
+					for (const identifier of getReferences(specifier)) if (isCallee(identifier)) report(identifier.parent, hook);
+					continue;
+				}
+				for (const identifier of getReferences(specifier)) {
+					const member = identifier.parent;
+					if (member.type !== "MemberExpression" || member.object !== identifier) continue;
+					const hook = getPropertyName(member);
+					if (hook !== void 0 && hooks.has(hook) && isCallee(member)) report(member.parent, hook);
+				}
+			}
+		} };
+	},
+	meta: {
+		defaultOptions: [{
+			allow: [...DEFAULT_ALLOW],
+			hooks: [...DEFAULT_HOOKS]
+		}],
+		docs: { description: "Disallow React state, effect, and memoization hooks in feature code. Hooks stay allowed in hook modules." },
+		messages: {
+			banned: "`{{hook}}` is not allowed in feature code. Move it into a hook module.",
+			effect: "`{{hook}}` runs a side effect in feature code. Move the side effect to a loader, an action, or an event handler.",
+			externalStore: "`{{hook}}` subscribes to an external store in feature code. Subscribe through a query or a store abstraction instead.",
+			localState: "`{{hook}}` keeps local state in feature code. Derive the value from loader data or URL params instead.",
+			memoization: "`{{hook}}` memoizes by hand. Remove it: the React Compiler handles memoization."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				allow: {
+					items: { type: "string" },
+					type: "array"
+				},
+				hooks: {
+					items: { type: "string" },
+					type: "array"
+				}
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+};
+//#endregion
+export { rule as default, globToRegExp };

package/dist/presets/lint/react-doctor.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/react-doctor.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/react-doctor.js

@@ -0,0 +1,20 @@
+//#region presets/lint/react-doctor.ts
+const config = {
+	jsPlugins: ["oxlint-plugin-react-doctor"],
+	rules: {
+		"react-doctor/no-create-store-in-render": "error",
+		"react-doctor/no-direct-state-mutation": "error",
+		"react-doctor/no-eager-new-in-use-state-initializer": "error",
+		"react-doctor/no-impure-state-updater": "error",
+		"react-doctor/no-mutating-reducer-state": "error",
+		"react-doctor/effect-observer-needs-disconnect": "error",
+		"react-doctor/effect-raf-loop-needs-cancel": "error",
+		"react-doctor/no-effect-event-handler": "error",
+		"react-doctor/no-event-trigger-state": "error",
+		"react-doctor/no-fetch-in-effect": "error",
+		"react-doctor/no-pass-live-state-to-parent": "error",
+		"react-doctor/no-set-state-after-await-in-effect": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/react-strict.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/react-strict.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/react-strict.js

@@ -0,0 +1,11 @@
+//#region presets/lint/react-strict.ts
+const PLUGIN_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const config = {
+	jsPlugins: [{
+		name: "adamantite",
+		specifier: new URL(`plugin/index.${PLUGIN_EXTENSION}`, import.meta.url).href
+	}],
+	rules: { "adamantite/no-react-state-hooks": "error" }
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/shadcn.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/shadcn.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/shadcn.js

@@ -0,0 +1,22 @@
+//#region presets/lint/shadcn.ts
+const config = {
+	jsPlugins: ["@shadcn/lint"],
+	overrides: [{
+		files: ["**/components/ui/**"],
+		rules: {
+			"shadcn/no-arbitrary-values": "off",
+			"shadcn/no-restyle": "off",
+			"shadcn/require-static-classes": "off"
+		}
+	}],
+	rules: {
+		"shadcn/no-arbitrary-values": ["error", { allow: ["layout"] }],
+		"shadcn/no-inline-styles": "error",
+		"shadcn/no-raw-colors": "error",
+		"shadcn/no-restyle": ["error", { allow: ["layout"] }],
+		"shadcn/no-unknown-classes": "error",
+		"shadcn/require-static-classes": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/strict.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/strict.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/strict.js

@@ -0,0 +1,18 @@
+//#region presets/lint/strict.ts
+const PLUGIN_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const config = {
+	jsPlugins: [{
+		name: "adamantite",
+		specifier: new URL(`plugin/index.${PLUGIN_EXTENSION}`, import.meta.url).href
+	}],
+	overrides: [{
+		files: ["**/*.{test,spec}.{ts,tsx,mts,cts}", "**/__tests__/**"],
+		rules: { "typescript/consistent-type-assertions": "error" }
+	}],
+	rules: {
+		"adamantite/no-overzealous-destructuring": "error",
+		"typescript/consistent-type-assertions": ["error", { assertionStyle: "never" }]
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/vendor/antislop/plugin.d.mts

@@ -1,11 +1,27 @@
 // Generated by scripts/vendor-plugins.ts — do not edit by hand.
 interface VendoredPluginRule {
-  readonly create: (context: never) => Record<string, never>
+  readonly create: (context: object) => Record<string, never>
 }
 
 declare const vendoredPlugin: {
   readonly meta: { readonly name: string }
-  readonly rules: { readonly [ruleName: string]: VendoredPluginRule }
+  readonly rules: {
+    readonly "no-chained-type-assertions": VendoredPluginRule
+    readonly "no-conditional-empty-object-spread": VendoredPluginRule
+    readonly "no-known-value-widening": VendoredPluginRule
+    readonly "no-module-mocking": VendoredPluginRule
+    readonly "no-object-parameters": VendoredPluginRule
+    readonly "no-reflect-apply": VendoredPluginRule
+    readonly "no-reflect-get": VendoredPluginRule
+    readonly "no-runtime-typeof": VendoredPluginRule
+    readonly "no-shape-in-symbol-names": VendoredPluginRule
+    readonly "no-unknown-parameters": VendoredPluginRule
+    readonly "no-unknown-returns": VendoredPluginRule
+    readonly "no-unknown-type-aliases": VendoredPluginRule
+    readonly "no-unsafe-dictionary-type": VendoredPluginRule
+    readonly "no-widen-then-assert": VendoredPluginRule
+    readonly "require-safety-comment-for-type-assertion": VendoredPluginRule
+  }
 }
 
 export default vendoredPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adamantite",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "An strict and opinionated set of presets for modern TypeScript applications",
   "keywords": [
     "adamantite",
@@ -58,18 +58,19 @@
   },
   "dependencies": {
     "@clack/prompts": "1.7.0",
-    "@effect/platform-node": "4.0.0-rc.115",
+    "@effect/platform-node": "4.0.0",
     "defu": "6.1.7",
-    "effect": "4.0.0-rc.115",
-    "esrap": "2.3.6",
+    "effect": "4.0.0",
     "jsonc-parser": "3.3.1",
     "nypm": "0.6.9",
-    "oxc-parser": "^0.147.0"
+    "oxc-parser": "0.150.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "1.0.0",
     "@changesets/cli": "3.0.1",
-    "@effect/vitest": "4.0.0-rc.115",
+    "@effect/vitest": "4.0.0",
+    "@oxlint/plugins": "1.83.0",
+    "@shadcn/lint": "0.1.5",
     "@tanstack/intent": "0.3.7",
     "@types/figlet": "1.7.0",
     "@types/node": "22.20.1",
@@ -79,6 +80,7 @@
     "knip": "6.32.2",
     "oxfmt": "0.65.0",
     "oxlint": "1.83.0",
+    "oxlint-plugin-react-doctor": "0.9.14",
     "oxlint-tsgolint": "7.0.2001",
     "sherif": "1.13.0",
     "tsdown": "0.22.14",
@@ -107,7 +109,9 @@
     "test:build": "node scripts/test-build.ts",
     "test:coverage": "vitest run --coverage",
     "test:dist": "pnpm run build && pnpm run test:build && pnpm run test:smoke",
+    "test:presets": "vitest run --project presets",
     "test:smoke": "node scripts/test-smoke.ts",
+    "test:unit": "vitest run --project unit",
     "test:watch": "vitest",
     "version": "changeset version"
   }

package/skills/adamantite/SKILL.md

@@ -28,12 +28,43 @@ npx adamantite init --non-interactive --script check --script fix --typescript -
 Repeat `--script`, `--preset`, and `--editor` for multiple values. Available values are:
 
 - Scripts: `check`, `fix`, `analyze`. In a detected monorepo, `analyze` also installs Sherif.
-  The legacy `check:monorepo` and `fix:monorepo` values are rejected.
-- Presets: `react`, `nextjs`, `vue`, `jest`, `vitest`, `node`, `antislop`; editors:
-  `vscode`, `zed`
+- Presets: `react`, `react-strict`, `react-doctor`, `nextjs`, `vue`, `jest`, `vitest`, `node`,
+  `strict`, `antislop`, `shadcn`;
+  editors: `vscode`, `zed`
 - Optional flags: `--typescript`, `--install-extensions`, `--github-actions`, `--agents`,
   `--overwrite-scripts`
 
+The `react-strict` preset needs no extra package. Its `adamantite/no-react-state-hooks` rule
+reports React state, effect, and memoization hooks outside hook modules (`useCart.ts`,
+`use-cart.ts`, and files under `hooks/`), and each message tells what to do instead. Do not move a hook call into
+a hook module only to silence the rule: follow the message. Set the rule's `allow` option
+when the project keeps hooks elsewhere.
+
+The `strict` preset needs no extra package either. Its `adamantite/no-overzealous-destructuring`
+rule reports destructuring nested more than 2 levels deep or object patterns with more than 5
+properties; keep the object and read its members, or split the pattern. Do not raise
+`maxDepth` or `maxProperties` only to silence a report. The preset also bans type assertions
+outside tests.
+
+The `react-doctor` preset requires the `react` preset and the `oxlint-plugin-react-doctor`
+package, which `init` installs at a pinned version and doctor and `update` keep in sync. It
+enables curated React Doctor rules for React state and effect misuse, such as
+`no-effect-event-handler` and `no-fetch-in-effect`, and adds to `react-strict`. The package has
+a modified MIT license: using it as machine learning training data or selling it as a
+hosted product needs written permission from the copyright holder. Tell the user before you
+select the preset.
+
+The `shadcn` preset needs Tailwind v4 and the `@shadcn/lint` package, which `init` installs
+at a pinned version and doctor and `update` keep in sync. The plugin finds components and
+the theme through `components.json`. Without that file it looks in `components/ui` or
+`src/components/ui` and discovers the stylesheet that imports Tailwind; when components
+live elsewhere, set `settings.shadcn` (for example `{ ui: "@/ds" }`) in `oxlint.config.ts`.
+The preset turns off the component-owned rules under `**/components/ui/**`; add the same
+override for another component directory.
+
+Adamantite requires TypeScript 7 or later as a dependency in the project's own
+`package.json`. Without that entry, npm cannot add or update a managed plugin.
+
 Only select options supported by the project. Presets and TypeScript require `check` or `fix`;
 extension installation requires an editor; `--github-actions` requires a CI-compatible script
 and a supported package manager (bun, deno, npm, pnpm, or yarn). Omitted boolean flags are
@@ -53,11 +84,10 @@ adamantite fix
 adamantite analyze
 ```
 
-- Use `check` for read-only formatting, lint, and type-error validation.
+- Use `check` for read-only formatting, lint, and type-error validation. `check --only lint` or `check --only format`
+  runs one stage.
 - Use `fix` for automatic Oxlint fixes followed by Oxfmt formatting. Add `--suggested`, `--dangerous`, or `--all` only
-  with explicit permission after reviewing their impact.
-- Do not use `format`. It is deprecated and the next release removes it. `fix` writes formatting changes and `check`
-  verifies formatting for read-only CI checks.
+  with explicit permission after reviewing their impact. `fix --only lint` or `fix --only format` runs one stage.
 - Use `analyze` for unused dependencies, exports, and files. In a monorepo it first checks
   workspace dependency consistency with Sherif. `analyze --only monorepo` or
   `analyze --only unused` runs one stage. `analyze --fix` may remove files, so inspect
@@ -68,8 +98,6 @@ adamantite analyze
   use `analyze --only unused --fix` to skip Sherif.
 - `analyze` runs Sherif without flags. Put Sherif exceptions in the `sherif` field of the root
   `package.json` (camelCase CLI options, e.g. `"ignoreDependency": ["tailwindcss"]`).
-- Do not use `monorepo`. It is deprecated and the next release removes it. Use `analyze`, or
-  `analyze --only monorepo` to run only Sherif.
 
 To pass arguments to Knip, Oxlint, or Sherif, place them after `--`. For `check` and `fix` they
 go to Oxlint. For `analyze` they go to Knip, or to the stage that `--only` selects, so a Sherif