onsystem 0.6.0 → 0.8.0

package/dist/eslint-worker.d.ts

@@ -1,4 +1,4 @@
-import { h as DesignSystemModel, i as ResolvedConfig } from "./config-lbfW91qB.js";
+import { h as DesignSystemModel, i as ResolvedConfig } from "./config-kYGiD5oW.js";
 import { MessagePort } from "node:worker_threads";
 //#region src/eslint/worker.d.ts
 export interface LoadRequest {

package/dist/eslint-worker.js

@@ -1,5 +1,5 @@
-import { H as DEFAULT_TEST_EXCLUDE, U as DEFAULT_TEST_FOLDERS, _t as relativePath, gt as matchesGlob, i as componentFiles, r as buildModel } from "./design-system-A3pRX3Ka.js";
-import { r as loadTarget } from "./workspace-CHvUwgz9.js";
+import { Q as excludedBy, Tt as relativePath, i as componentFiles, r as buildModel } from "./design-system-Dmcv7eHR.js";
+import { r as loadTarget } from "./workspace-CM1RyqZA.js";
 import fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";
@@ -14,8 +14,6 @@ const warned = /* @__PURE__ */ new Set();
 /** How long a loaded design system is trusted before its files are looked at again. */
 const FRESH_MS = 2e3;
 const targets = /* @__PURE__ */ new Map();
-/** The default test and story patterns: the recommended config ignores those files itself. */
-const TEST_PATTERNS = /* @__PURE__ */ new Set([DEFAULT_TEST_EXCLUDE, DEFAULT_TEST_FOLDERS]);
 const projects = /* @__PURE__ */ new Map();
 function realPath(file) {
 	try {
@@ -65,7 +63,7 @@ async function load(request) {
 		projects.set(config.root, project);
 	}
 	const relative = relativePath(config.root, request.file);
-	const excluded = config.exclude.find((pattern) => !TEST_PATTERNS.has(pattern) && matchesGlob(relative, pattern));
+	const excluded = excludedBy(config, relative, { includeTests: true });
 	if (excluded) return { skip: `excluded by "${excluded}"` };
 	if (!config.includeDesignSystem && project.own.has(realPath(request.file))) return { skip: "one of the design system’s own component files" };
 	const { version } = project;

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { H as DEFAULT_TEST_EXCLUDE, T as RULES, U as DEFAULT_TEST_FOLDERS, V as DEFAULT_SEVERITY, _ as VERSION, _t as relativePath, g as NAME, t as DesignSystem } from "./design-system-A3pRX3Ka.js";
+import { G as DEFAULT_SEVERITY, K as DEFAULT_TEST_EXCLUDE, Tt as relativePath, _ as NAME, k as RULES, q as DEFAULT_TEST_FOLDERS, t as DesignSystem, v as VERSION } from "./design-system-Dmcv7eHR.js";
 import path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 //#region src/eslint/bridge.ts
@@ -96,8 +96,63 @@ function run(cwd, file, text, settings) {
 		designSystems.set(response.root, entry);
 	}
 	if (!entry) return { error: `no design system loaded for ${response.root}` };
-	const result = entry.ds.check(text, relativePath(entry.ds.root, file));
-	return result.skipped ? { skipped: true } : { result };
+	const { ds } = entry;
+	const relative = relativePath(ds.root, file);
+	const result = ds.check(text, relative);
+	if (result.skipped) return { skipped: true };
+	return {
+		result,
+		fromSystem: (specifier) => ds.lint.isDesignSystemImport(specifier, relative)
+	};
+}
+/**
+* The name an edit gives a JSX tag when that name does not mean the component there: `Button`
+* for `<button>` → `<Button>` in a file that does not import it, imports it as a type only, or
+* imports another `Button` from outside the design system. Applied, such a rename leaves a file
+* that does not compile.
+*/
+function unboundRename(sourceCode, edit, fromSystem) {
+	if (!edit.text.includes(".") && /^[a-z]/.test(edit.text)) return;
+	const [start, end] = edit.range;
+	let node = sourceCode.getNodeByRangeIndex(start);
+	while (node && (node.range[0] !== start || node.range[1] !== end)) node = node.parent ?? null;
+	const tag = node?.parent;
+	if (!node || !tag || !["JSXOpeningElement", "JSXClosingElement"].includes(tag.type)) return;
+	if (tag.name !== node) return;
+	const name = edit.text.split(".")[0] ?? edit.text;
+	for (let scope = sourceCode.getScope(node); scope; scope = scope.upper) {
+		const values = scope.set.get(name)?.defs.filter((def) => !typeOnly(def)) ?? [];
+		if (!values.length) continue;
+		return values.some((def) => isComponent(def, fromSystem)) ? void 0 : edit.text;
+	}
+	return edit.text;
+}
+/**
+* Whether a value binding can be the component a rename names: an import from the design
+* system, or a function, class, variable or parameter of the file. Not an import of the same
+* name from elsewhere (`Table<TData>` from @tanstack/react-table without `type`, an app's own
+* `Label`), nor an enum or a namespace.
+*/
+function isComponent(def, fromSystem) {
+	if (def.type === "ImportBinding") {
+		const source = def.parent?.source?.value;
+		return typeof source === "string" && fromSystem(source);
+	}
+	return [
+		"FunctionName",
+		"ClassName",
+		"Variable",
+		"Parameter"
+	].includes(def.type);
+}
+/**
+* A binding that is only a type: a type alias, interface or type parameter (typescript-eslint's
+* `Type` definition), or `import type { Button }` and `import { type Button }` (its `importKind`).
+*/
+function typeOnly(def) {
+	if (def.type === "Type") return true;
+	const kind = (node) => node?.importKind;
+	return def.type === "ImportBinding" && (kind(def.node) === "type" || kind(def.parent) === "type");
 }
 function createRule(id, description) {
 	return {
@@ -108,6 +163,7 @@ function createRule(id, description) {
 				url: `${RULES_PAGE}#${id}`
 			},
 			fixable: "code",
+			hasSuggestions: true,
 			schema: []
 		},
 		create(context) {
@@ -128,7 +184,9 @@ function createRule(id, description) {
 				}
 				for (const d of outcome.result.diagnostics) {
 					if (d.ruleId !== id) continue;
-					const edits = d.fix;
+					const edits = d.fix ?? [];
+					const fix = (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text));
+					const unbound = edits.map((e) => unboundRename(context.sourceCode, e, outcome.fromSystem)).find((name) => name !== void 0);
 					context.report({
 						loc: {
 							start: {
@@ -141,7 +199,10 @@ function createRule(id, description) {
 							}
 						},
 						message: d.message,
-						...edits?.length ? { fix: (fixer) => edits.map((e) => fixer.replaceTextRange(e.range, e.text)) } : {}
+						...!edits.length ? {} : unbound ? { suggest: [{
+							desc: `Rename to <${unbound}>, then import it`,
+							fix
+						}] } : { fix }
 					});
 				}
 			} };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-lbfW91qB.js";
+import { C as TOKEN_CATEGORIES, D as VariantInfo, E as TokenCategory, O as ImportMapping, S as SourceLocation, T as Token, _ as DocSection, a as ResolvedRule, b as PropInfo, c as configJsonSchema, d as CheckResult, f as ComponentDocs, g as Diagnostic, h as DesignSystemModel, i as ResolvedConfig, l as defineConfig, m as CompoundVariantInfo, n as LoadConfigOptions, o as RuleId, p as ComponentInfo, r as RULE_IDS, s as RuleOptions, t as Config, u as loadConfig, v as ExampleInfo, w as TextEdit, x as Severity, y as InheritedProps } from "./config-kYGiD5oW.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
@@ -214,8 +214,19 @@ interface ColorSuggestion {
   reason?: 'far' | 'hue' | 'role' | 'status' | 'scoped' | undefined;
   /** With reason `status`: how far apart the hues are, in degrees. */
   hueOff?: number | undefined;
+  /**
+   * With reason `role`: a token that is close and of the same hue but made for
+   * another role (`content-muted`, a text color, for a border), when it is not the nearest.
+   */
+  otherRole?: Nearest<ColorCandidate> | undefined;
   /** Other tokens with the nearest one's value. */
   sameValue: Token[];
+  /**
+   * With a match that is no status color: a close status color of the color's hue that is
+   * about as near (within STATUS_MARGIN), so the color may mean that status (a red error
+   * message next to a rose brand), and the match is no sure fix.
+   */
+  closeStatus?: Nearest<ColorCandidate> | undefined;
 }
 interface NearestLength extends Nearest<LengthCandidate> {
   /** A radius so far above the scale that it means "fully rounded" (`rounded-full`). */
@@ -311,6 +322,14 @@ declare class LintTarget {
    * directory itself (a barrel: `../components/ui` and its index).
    */
   isDesignSystemImport(specifier: string, fromFile?: string): boolean;
+  /**
+   * Whether the component rules judge the components imported from `specifier`: it points at
+   * the design system, and the model has components to judge them by. A model with none (an
+   * app whose design-system package publishes only compiled `dist/`) still matches the
+   * configured `importPath`, but the component rules do not run there, as `check` says, so
+   * what comes from it is not called invented.
+   */
+  checksImport(specifier: string, fromFile?: string): boolean;
   /**
    * Whether `name`, imported from the design system, may be a real export the
    * model left out rather than an invented one: its module exists outside the
@@ -522,11 +541,24 @@ export declare class DesignSystem {
   private readonly searchIndex;
   /**
    * The components the tools offer: all of them, except a library's (MUI's) where the project
-   * has its own of that name, a wrapper the team means to be used. The rules still check code
-   * that imports the library's directly against the library's.
+   * has its own of that name, a wrapper the team means to be used, and the helpers in a
+   * registry folder's `lib/` (signoff-ui's `Img` and icons). The rules still check code that
+   * imports either directly against them.
    */
   private readonly offered;
+  /** The design systems the rules rank, with the registry folders a config lists. */
+  private readonly sources;
   constructor(model: DesignSystemModel, config: ResolvedConfig);
+  /**
+   * The shadcn registry a component was copied from (`@signoff-ui`), when its folder is one
+   * components.json names: a read-only design system, whose code is the registry's.
+   */
+  registryOf(component: ComponentInfo): {
+    registry: string;
+    folder: string;
+  } | undefined;
+  /** A component in a registry folder's `lib/`: an internal of its items, not one of them. */
+  private registryHelper;
   get root(): string;
   get components(): ComponentInfo[];
   get tokens(): Token[];

package/dist/index.js

@@ -1,3 +1,3 @@
-import { $ as findVariantDefinitions, A as toDtcg, D as loadTokens, E as TokenIndex, F as attachDocs, G as RULE_IDS, I as parseDoc, K as configJsonSchema, L as extractComponents, M as parseDtcgTokens, N as parseDesignMd, O as mergeTokens, P as parseCssTokens, T as RULES, Y as loadConfig, _ as VERSION, a as fingerprint, d as searchComponents, f as applyFixes, h as formatDiagnostics, k as toDesignMd, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, q as defineConfig, r as buildModel, t as DesignSystem } from "./design-system-A3pRX3Ka.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-CEChNFLR.js";
+import { A as TokenIndex, B as parseDoc, I as parseDtcgTokens, L as parseDesignMd, M as mergeTokens, N as toDesignMd, P as toDtcg, R as parseCssTokens, V as extractComponents, X as configJsonSchema, Y as RULE_IDS, Z as defineConfig, a as fingerprint, d as searchComponents, et as loadConfig, f as applyFixes, g as formatDiagnostics, it as findVariantDefinitions, j as loadTokens, k as RULES, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, r as buildModel, t as DesignSystem, v as VERSION, z as attachDocs } from "./design-system-Dmcv7eHR.js";
+import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-MTS6QAgo.js";
 export { DesignSystem, DesignSystemHost, INSTRUCTIONS, RULES, RULE_IDS, TokenIndex, VERSION, applyFixes, attachDocs, buildModel, checkSource, configJsonSchema, createServer, defineConfig, extractComponents, findVariantDefinitions, fingerprint, formatDiagnostics, loadConfig, loadDesignSystem, loadTokens, mergeTokens, parseCssTokens, parseDesignMd, parseDoc, parseDtcgTokens, searchComponents, serveStdio, toDesignMd, toDtcg };

package/dist/{stdio-CEChNFLR.js → stdio-MTS6QAgo.js}

@@ -1,5 +1,5 @@
-import { Q as formatPx, R as CONFIG_FILES, W as LEGACY_CONFIG_FILES, Y as loadConfig, _ as VERSION, _t as relativePath, d as searchComponents, dt as closest, ft as plural, g as NAME, ht as isInside, j as TOKEN_CATEGORIES, m as uncheckedNotice, mt as unique, n as DesignSystemHost, pt as truncate, u as buildSearchIndex } from "./design-system-A3pRX3Ka.js";
-import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-CHvUwgz9.js";
+import { Ct as isInside, Dt as defaultProjectConfig, F as TOKEN_CATEGORIES, G as DEFAULT_SEVERITY, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, Q as excludedBy, St as SCRIPT_FILE, Tt as relativePath, Y as RULE_IDS, _ as NAME, at as LIBRARIES, bt as truncate, ct as notReadYet, d as searchComponents, et as loadConfig, ft as detectProject, m as uncheckedNotice, n as DesignSystemHost, ot as LIBRARY_IDS, pt as findDesignSystemPackage, rt as formatPx, st as libraryTitle, u as buildSearchIndex, v as VERSION, vt as closest, xt as unique, yt as plural } from "./design-system-Dmcv7eHR.js";
+import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-CM1RyqZA.js";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -7,6 +7,214 @@ import * as z from "zod";
 import fsp from "node:fs/promises";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
+//#region src/explain.ts
+/**
+* What `inspect --explain` says about one project: every candidate zero config looked
+* at and why each was taken or not, the config it resolved to, tokens whose value did
+* not resolve, and components without props, with the likely reason.
+*/
+function explainProject(ds, cwd, indent = "") {
+	const { config, model } = ds;
+	const lines = [];
+	const out = (line = "") => lines.push(line ? `${indent}${line}` : "");
+	out("How the design system was found");
+	for (const step of packageSteps(config, cwd)) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
+	if (config.configured) out(`  components come from ${config.configFile ? display(cwd, config.configFile) : "--components"}, so zero config did not look`);
+	else {
+		const steps = [];
+		detectProject(config.root, config.tsconfig, steps, config.designSystemPackage);
+		for (const step of steps) out(`  ${(step.accepted ? "found" : "no").padEnd(6)} ${step.candidate}: ${step.reason}`);
+		if (!config.detected) out(`  So the defaults apply: ${config.components.join(", ")}${model.stats.files.components ? "" : ", which match nothing"}.`);
+	}
+	const named = (library) => `${library.package}${library.version ? ` ${library.version}` : ""}`;
+	for (const library of config.libraries ?? []) {
+		const count = model.components.filter((c) => c.library === library.package).length;
+		out(library.dir ? `  ${"found".padEnd(6)} ${named(library)}: a dependency, ${count} components from its type declarations in ${display(cwd, library.dir)}` : `  ${"no".padEnd(6)} ${named(library)}: a dependency, but not installed`);
+	}
+	for (const library of config.librariesOff ?? []) out(`  ${"no".padEnd(6)} ${named(library)}: a dependency, ${librariesLeftOut(config, cwd)}`);
+	for (const library of config.librariesUnread ?? []) out(`  ${"no".padEnd(6)} ${named(library)}: ${notReadYet()}`);
+	out();
+	out("Resolved config");
+	const field = (name, value) => out(`  ${name.padEnd(12)} ${value}`);
+	field("root", config.root);
+	field("config", config.configFile ? `${display(cwd, config.configFile)}${config.designSystemPackage ? ` (declared by ${config.designSystemPackage.name})` : ""}` : "(none)");
+	field("components", listOf$3(config.components) || "(none)");
+	field("exclude", listOf$3(config.exclude));
+	field("tokens", listOf$3(config.tokens.map((t) => `${t.path}${t.prefix ? ` (prefix ${t.prefix})` : ""}${t.fallback ? " (when nothing else is found)" : ""}`)));
+	field("docs", listOf$3(config.docs));
+	const projectConfig = defaultProjectConfig(config.root);
+	field("tsconfig", config.tsconfig ?? (projectConfig ? display(config.root, projectConfig) : "(none)"));
+	field("importPath", importPaths(ds));
+	field("libraries", config.libraryIds === void 0 ? `every library onsystem reads (${LIBRARY_IDS.join(", ")})` : config.libraryIds !== false && config.libraryIds.length ? config.libraryIds.join(", ") : `none ("libraries": ${JSON.stringify(config.libraryIds)})`);
+	if (config.tailwindConfig) field("tailwind", display(config.root, config.tailwindConfig));
+	if (config.designSystems) {
+		const ranked = config.designSystems.filter((d) => !d.registry).length > 1;
+		field("primary", config.designSystems.map((d, i) => `${i ? "then " : ""}${d.source}${d.registry ? ", read-only" : ranked ? ` (${d.imports} imports)` : ""}`).join("; "));
+	}
+	const changed = RULE_IDS.filter((id) => config.rules[id].severity !== DEFAULT_SEVERITY[id]);
+	field("rules", `${RULE_IDS.map((id) => `${id} ${config.rules[id].severity}`).join(", ")}${changed.length ? ` (changed: ${changed.join(", ")})` : ""}`);
+	if (config.overrides?.length) for (const override of config.overrides) field("override", `${override.files.join(", ")}: ${Object.entries(override.rules).map(([id, rule]) => `${id} ${rule.severity}`).join(", ")}`);
+	if (config.base) field("relative to", `${config.base} (a config at the workspace root)`);
+	out();
+	out("Tokens");
+	const found = ds.tokens;
+	const files = model.stats.files.tokens;
+	const themed = found.filter((t) => t.origin === "library");
+	out(`  ${found.length - themed.length} tokens from ${files} ${files === 1 ? "file" : "files"}${files ? "" : `: no file matches ${config.tokens.map((t) => t.path).join(", ")}`}`);
+	if (themed.length) {
+		const sources = [...new Set(themed.map((t) => t.source.file))];
+		out(`  ${themed.length} tokens from a library's theme in ${sources.join(", ")}`);
+	}
+	const defined = new Set(found.map((t) => t.cssVar).filter((v) => Boolean(v)));
+	const missing = (value) => [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1] ?? "").filter((v) => !defined.has(v));
+	const unresolved = found.filter((t) => missing(t.value).length);
+	if (unresolved.length) out(`  ${unresolved.length} unresolved, reading a custom property no token file defines: ${unresolved.slice(0, 8).map((t) => `${t.cssVar ?? t.name}: ${t.value}`).join(", ")}${unresolved.length > 8 ? `, and ${unresolved.length - 8} more` : ""}`);
+	else if (found.length) out("  every value resolves");
+	for (const warning of model.warnings.filter((w) => /alias|token/i.test(w))) out(`  ${warning}`);
+	out();
+	out("Props");
+	const empty = ds.roots().filter((c) => c.openProps && !c.props.length && !c.inherits.length);
+	const open = ds.components.filter((c) => c.openProps);
+	if (!open.length) out(`  every component's props resolved (${ds.components.length} components)`);
+	else {
+		const installed = nodeModulesFor(config.root);
+		const names = (list) => `${list.slice(0, 6).map((c) => c.name).join(", ")}${list.length > 6 ? ` and ${list.length - 6} more` : ""}`;
+		if (empty.length) out(`  ${empty.length} ${empty.length === 1 ? "component has" : "components have"} 0 props: ${names(empty)}.`);
+		out(`  ${open.length} ${open.length === 1 ? "component has" : "components have"} props that did not fully resolve${empty.length === open.length ? "" : `: ${names(open)}`}, so no-unknown-prop skips ${open.length === 1 ? "it" : "them"}.`);
+		out(installed ? `  Dependencies are installed (${display(cwd, installed)}): a package without types, a type error, or a props type that depends on a type argument leaves them open.` : `  The dependencies are not installed: no node_modules in ${config.root} or a folder above it. Their props come from the packages they wrap (Radix, React Aria), so install them (npm install, pnpm install) and run again.`);
+	}
+	return lines;
+}
+/** Why a library the project depends on is not read: `left out by "libraries" in onsystem.config.json`. */
+function librariesLeftOut(config, cwd) {
+	return `left out by "libraries" in ${config.configFile ? display(cwd, config.configFile) : "the config"}`;
+}
+/** The first few, then how many more: a package's exports can name hundreds of files. */
+function listOf$3(items, max = 8) {
+	const shown = items.slice(0, max).join(", ");
+	return items.length > max ? `${shown}, and ${items.length - max} more` : shown;
+}
+/** How components are suggested to be imported. */
+function importPaths(ds) {
+	if (ds.config.importPath) return `${ds.config.importPath} (from the config)`;
+	const counts = /* @__PURE__ */ new Map();
+	for (const c of ds.roots()) counts.set(c.importPath, (counts.get(c.importPath) ?? 0) + 1);
+	const top = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 3);
+	const from = ds.config.imports?.length ? "package exports" : "tsconfig paths or relative paths";
+	return top.length ? `inferred from ${from}: ${top.map(([p, n]) => `${p} (${n})`).join(", ")}${counts.size > 3 ? `, and ${counts.size - 3} more` : ""}` : `inferred from ${from}`;
+}
+/** The nearest node_modules at or above `dir`, if any. */
+function nodeModulesFor(dir) {
+	for (let current = path.resolve(dir);; current = path.dirname(current)) {
+		const candidate = path.join(current, "node_modules");
+		if (fs.existsSync(candidate)) return candidate;
+		if (current === path.dirname(current)) return void 0;
+	}
+}
+function display(cwd, file) {
+	const rel = relativePath(cwd, file);
+	return rel && !rel.startsWith("..") ? rel : file;
+}
+/**
+* Whether a dependency's declared config was taken on, for a project without a config of its
+* own: the package it came from and the others that declare one, or that none does.
+*/
+function packageSteps(config, cwd) {
+	const declared = config.designSystemPackage;
+	if (config.configFile && !declared) return [];
+	const lookup = findDesignSystemPackage(config.root);
+	if (!lookup) return [];
+	const candidate = "a design-system package's config";
+	const skipped = lookup.skipped.length ? `; ${lookup.skipped.map((p) => p.name).join(", ")} ${lookup.skipped.length === 1 ? "declares one" : "declare one"} that cannot be read, skipped since installed` : "";
+	if (!declared) return [{
+		candidate,
+		accepted: false,
+		reason: `no dependency declares one ("onsystem" in its package.json) among ${lookup.dependencies} ${lookup.dependencies === 1 ? "dependency" : "dependencies"}${skipped}`
+	}];
+	return [{
+		candidate,
+		accepted: true,
+		reason: `${declared.name} (${declared.installed ? "installed" : "a workspace package"}) declares ${display(cwd, declared.config)}, which this project takes on, with its paths from ${display(cwd, declared.dir)}${lookup.others.length ? `; ${lookup.others.join(", ")} also declare one, not read: one config is taken on, from the package the code imports most` : ""}${skipped}`
+	}];
+}
+//#endregion
+//#region src/not-read.ts
+const LIMITS_DOCS = "https://onsystem.vercel.app/docs/how-it-works#limits";
+/**
+* What `check` and `check_ui` could not read, said after the results as the notice for missing
+* components and tokens is, so a clean result is not mistaken for a checked one: a component
+* library the project depends on that onsystem does not read yet, and dependencies that are not
+* installed. Projects with the same gap share one notice that names them.
+*/
+function notReadNotices(projects) {
+	return [...unreadLibraries(projects), missingDependencies(projects)].filter((notice) => notice !== void 0);
+}
+/**
+* A component library onsystem does not read yet (Chakra UI, Mantine), in a project without
+* components of its own, whose code is then checked by the accessibility rule alone. One notice
+* per set of libraries.
+*/
+function unreadLibraries(projects) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const { ds, dir } of projects) {
+		const packages = (ds.config.librariesUnread ?? []).map((library) => library.package);
+		if (!packages.length || ds.components.length) continue;
+		const key = packages.join(" ");
+		const group = groups.get(key) ?? {
+			packages,
+			dirs: []
+		};
+		if (dir !== void 0) group.dirs.push(dir);
+		groups.set(key, group);
+	}
+	return [...groups.values()].map(({ packages, dirs }) => {
+		const one = packages.length === 1;
+		const names = listOf$2(packages.map((name) => `${libraryTitle(name)} (${name})`), packages.length);
+		const of = dirs.length ? ` of ${listOf$2(dirs)}` : "";
+		return `${names} ${one ? "is a dependency" : "are dependencies"}${of}, but onsystem does not read ${one ? "it" : "them"} yet: of the published component libraries, it reads only ${LIBRARIES.map((l) => l.title).join(", ")} so far. Wrap ${one ? "its" : "their"} components in your own and point "components" in the config at those. See ${LIMITS_DOCS}`;
+	});
+}
+/**
+* Dependencies that are not installed: no `node_modules` at or above a project that declares
+* some, so the props of components that come from them (Radix, React's own) do not resolve and
+* `no-unknown-prop` skips those components. For plain `inspect` too, on stderr.
+*/
+function missingDependencies(projects) {
+	const dirs = [];
+	let skipped = 0;
+	for (const { ds, dir } of projects) {
+		if (ds.config.rules["no-unknown-prop"].severity === "off") continue;
+		const open = ds.components.filter((c) => c.openProps).length;
+		if (!open || nodeModulesFor(ds.config.root) || !declaresDependencies(ds.config.root)) continue;
+		skipped += open;
+		if (dir !== void 0) dirs.push(dir);
+	}
+	if (!skipped) return void 0;
+	return `The dependencies${dirs.length ? ` of ${listOf$2(dirs)}` : ""} are not installed (no node_modules): no-unknown-prop skips ${plural(skipped, "component")} whose props come from them. Install them (npm install, pnpm install) and run again.`;
+}
+/** Whether `root`'s package.json lists dependencies, devDependencies or peerDependencies. */
+function declaresDependencies(root) {
+	try {
+		const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+		return [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies"
+		].some((field) => {
+			const value = pkg[field];
+			return Boolean(value && typeof value === "object" && Object.keys(value).length);
+		});
+	} catch {
+		return false;
+	}
+}
+/** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
+function listOf$2(items, max = 3) {
+	if (items.length <= 1) return items[0] ?? "";
+	if (items.length <= max) return `${items.slice(0, -1).join(", ")} and ${items.at(-1) ?? ""}`;
+	return `${items.slice(0, max).join(", ")} and ${items.length - max} more`;
+}
+//#endregion
 //#region src/server/render.ts
 /**
 * Tool results are read by models, so they are rendered as compact Markdown:
@@ -31,7 +239,7 @@ function renderComponentList(ds, project) {
 	const parts = ds.components.length - roots.length;
 	const lines = [`${plural(roots.length, "component")}${parts ? ` (+${plural(parts, "part")})` : ""}${project ? ` in ${project}` : ""}. Call get_component before using one.`, ""];
 	const own = roots.filter((c) => !c.library);
-	for (const component of own) lines.push(...listItem(component));
+	for (const component of own) lines.push(...listItem(component, registryNote(ds, component)));
 	for (const library of new Set(roots.flatMap((c) => c.library ? [c.library] : []))) {
 		if (own.length) lines.push("");
 		lines.push(`From ${library} (import { Name } from "${library}"):`, "");
@@ -39,6 +247,11 @@ function renderComponentList(ds, project) {
 	}
 	return lines.join("\n");
 }
+/** ` (from @signoff-ui, read-only)` for a component copied from a shadcn registry. */
+function registryNote(ds, component) {
+	const from = ds.registryOf(component);
+	return from ? ` (from ${from.registry}, read-only)` : "";
+}
 function listItem(component, note = "", withImport = true) {
 	const element = component.element ? ` <${component.element}>` : "";
 	const lines = [`${component.name}${element}${note} — ${firstSentence(component.description) || "No description."}`];
@@ -171,6 +384,8 @@ function renderComponent(ds, component, origin) {
 	].filter(Boolean);
 	lines.push(facts.join(" · "));
 	if (origin) lines.push(`From ${origin.package}, used by ${listOf$1(origin.projects)}.`);
+	const registry = ds.registryOf(component);
+	if (registry) lines.push(`Installed from the shadcn registry ${registry.registry} into ${registry.folder}: use it as it is. Its code is the registry's, so change it upstream, not here; \`npx shadcn add --overwrite\` replaces the file.`);
 	lines.push("", "## Props");
 	if (!component.props.length && !component.inherits.length) lines.push("No props.");
 	for (const prop of component.props) lines.push(renderProp(prop));
@@ -360,6 +575,10 @@ const MAX_CODE = 1e6;
 /** Diagnostics check_ui returns by default: a 3,000-line file can have thousands, more than a context holds. */
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 1e3;
+/** check_ui's answer for a path or filename that is not JS or TS. */
+function notScript(name) {
+	return errorResult(`check_ui checks .tsx, .jsx, .ts and .js files; ${name} is not one, so it was not checked.`);
+}
 /**
 * An integer, without the ±9007199254740991 bounds zod adds to the JSON Schema,
 * which every client would otherwise read in each tool definition.
@@ -794,7 +1013,7 @@ function createServer({ getDesignSystem, getProjects }) {
 		description: "Lint TSX/JSX against the design system. Reports hardcoded colors, spacing and radius (with the nearest token), native elements that have a design-system component, unknown components, props and variant values, and icon-only buttons without an accessible name. Each diagnostic has line/column, a rule id, a message and a suggested fix. Run it on every snippet or file you write and fix all errors. Pass `code` for unsaved code, or `path` for a file in the project.",
 		inputSchema: z.object({
 			code: z.string().max(MAX_CODE).optional().describe(`TSX/JSX source to check (up to ${MAX_CODE.toLocaleString("en")} characters).`),
-			path: z.string().max(MAX_PATH).optional().describe("Path of a file to check: relative to the project root (the monorepo root, when served from there), or absolute."),
+			path: z.string().max(MAX_PATH).optional().describe("Path of a .tsx, .jsx, .ts or .js file to check: relative to the project root (the monorepo root, when served from there), or absolute."),
 			filename: z.string().max(MAX_PATH).optional().describe("Name to report `code` under; a .jsx extension parses it as JSX. At a monorepo root, the path the code will be saved under, which picks the project whose design system checks it. When the server was started outside your project, pass it as an absolute path: the project is found from it."),
 			limit: z.number().int().min(1).max(MAX_LIMIT).default(DEFAULT_LIMIT).describe(`Most diagnostics to return, errors first (default ${DEFAULT_LIMIT}). The counts and byRule cover all of them.`)
 		}),
@@ -809,16 +1028,17 @@ function createServer({ getDesignSystem, getProjects }) {
 				errors: int(),
 				warnings: int()
 			})).describe("Every finding per rule, shown or not."),
-			skipped: z.string().optional().describe("Why the file was not checked: it renders an image (next/og) or an email."),
+			skipped: z.string().optional().describe("Why the file was not checked: it renders an image (next/og) or an email, or the config's `exclude` leaves it out."),
 			unchecked: z.object({
 				names: z.array(z.string()),
 				modules: z.array(z.string())
 			}).optional().describe("Components imported from modules the model does not include, not checked."),
-			notice: z.string().optional().describe("Set when no components or no color tokens were found, so rules did not run, or when components came from modules the model does not include.")
+			notice: z.string().optional().describe("Set when no components or no color tokens were found, so rules did not run, when components came from modules the model does not include, when the project depends on a component library onsystem does not read yet, or when its dependencies are not installed.")
 		}),
 		annotations: READ_ONLY
 	}, async ({ code, path: filePath, filename, limit }) => {
 		if (code === void 0 && !filePath) return errorResult("Pass either `code` or `path`.");
+		if (code !== void 0 && filename !== void 0 && !SCRIPT_FILE.test(filename)) return notScript(filename);
 		const routeBy = code === void 0 ? filePath : filename ?? void 0;
 		const set = await getProjects?.(routeBy);
 		let ds;
@@ -843,6 +1063,7 @@ function createServer({ getDesignSystem, getProjects }) {
 			const absolute = path.resolve(base, filePath);
 			const outside = errorResult(`${filePath} is outside the project root (${base}).`);
 			if (!isInside(base, absolute)) return outside;
+			if (!SCRIPT_FILE.test(absolute)) return notScript(filePath);
 			try {
 				const [root, real] = await Promise.all([fsp.realpath(base), fsp.realpath(absolute)]);
 				if (!isInside(root, real)) return outside;
@@ -866,13 +1087,24 @@ function createServer({ getDesignSystem, getProjects }) {
 			file = relativePath(ds.root, absolute);
 			shown = relativePath(base, absolute);
 		}
-		const checked = ds.check(source, file);
+		const excluded = (filename !== void 0 || code === void 0) && !path.isAbsolute(file) ? excludedBy(ds.config, file) : void 0;
+		const checked = excluded ? {
+			file,
+			diagnostics: [],
+			errorCount: 0,
+			warningCount: 0,
+			skipped: `It is left out by "${excluded}" in the config's exclude, as in check, the ESLint plugin and the Claude Code hook.`
+		} : ds.check(source, file);
 		const result = file === shown ? checked : {
 			...checked,
 			file: shown
 		};
 		const capped = capDiagnostics(result, limit);
-		const notice = result.skipped ? void 0 : [ds.notice(), uncheckedNotice([result])].filter(Boolean).join("\n\n") || void 0;
+		const notice = result.skipped ? void 0 : [
+			ds.notice(),
+			...notReadNotices([{ ds }]),
+			uncheckedNotice([result])
+		].filter(Boolean).join("\n\n") || void 0;
 		return {
 			content: [{
 				type: "text",
@@ -1393,4 +1625,4 @@ async function clientRoot(server) {
 	}
 }
 //#endregion
-export { INSTRUCTIONS as n, createServer as r, serveStdio$1 as t };
+export { notReadNotices as a, missingDependencies as i, INSTRUCTIONS as n, explainProject as o, createServer as r, librariesLeftOut as s, serveStdio$1 as t };

package/dist/{workspace-CHvUwgz9.js → workspace-CM1RyqZA.js}

@@ -1,4 +1,4 @@
-import { J as hasOwnConfig, R as CONFIG_FILES, W as LEGACY_CONFIG_FILES, X as loadConfigWith, Y as loadConfig, _t as relativePath, ct as isWorkspaceRoot, ht as isInside, i as componentFiles, lt as workspacePackageDirs, ot as findDesignSystemPackage, rt as PackageFinder, ut as workspacePatterns } from "./design-system-A3pRX3Ka.js";
+import { $ as hasOwnConfig, Ct as isInside, H as CONFIG_FILES, J as LEGACY_CONFIG_FILES, Tt as relativePath, _t as workspacePatterns, et as loadConfig, gt as workspacePackageDirs, ht as isWorkspaceRoot, i as componentFiles, pt as findDesignSystemPackage, tt as loadConfigWith, ut as PackageFinder } from "./design-system-Dmcv7eHR.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "onsystem",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "mcpName": "io.github.dgesteves/onsystem",
-  "description": "Keeps coding agents on your design system: it knows your real components, props, variants and tokens, catches the moment an agent invents one and has it fix it, and the same check gates your PRs. Local, zero config, works alongside @shadcn/lint.",
+  "description": "Keeps coding agents on your design system: catches palette colors, native elements and APIs your system lacks, at every edit and pull request, with the fix. Set it up once in your design-system package; every app in your monorepo gets it.",
   "keywords": [
     "design-system",
     "design-system-lint",
@@ -69,10 +69,10 @@
     "tinyglobby": "^0.2.17",
     "typescript": "~6.0.3",
     "yaml": "^2.9.1",
-    "zod": "^4.6.5"
+    "zod": "^4.6.6"
   },
   "peerDependencies": {
-    "eslint": ">=9.0.0"
+    "eslint": ">=8.57.0"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -86,7 +86,7 @@
     "@modelcontextprotocol/client": "^2.3.1",
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@types/culori": "^4.0.1",
-    "@types/node": "^24.19.1",
+    "@types/node": "^24.19.2",
     "ajv": "^8.20.0",
     "ajv-draft-04": "^1.0.0",
     "ajv-formats": "^3.0.1",
@@ -96,11 +96,11 @@
     "geist": "^1.7.2",
     "globals": "^17.13.0",
     "opentype.js": "^2.0.0",
-    "prettier": "^3.9.9",
+    "prettier": "^3.9.10",
     "publint": "^0.3.25",
-    "react-aria-components": "^1.21.1",
+    "react-aria-components": "^1.22.1",
     "tailwind-variants": "^3.3.1",
-    "tsdown": "^0.23.0",
+    "tsdown": "^0.23.1",
     "typescript-eslint": "^8.71.1",
     "vitest": "^5.0.3"
   },
@@ -114,7 +114,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "smoke": "node scripts/smoke.mjs",
-    "pack-test": "node scripts/pack-test.mjs",
+    "pack-test": "node scripts/pack-test.mjs && node scripts/pack-test-eslint8.mjs",
     "assets": "node scripts/build-assets.mjs",
     "palette": "node scripts/build-palette.mjs",
     "sync-plugins": "node scripts/sync-plugins.mjs",

package/schema.json

@@ -22,7 +22,7 @@
       ]
     },
     "exclude": {
-      "description": "Globs to ignore when finding components and when `check` expands folders and globs (stories, tests). Replaces the defaults; node_modules is skipped either way unless a pattern names it.",
+      "description": "Globs for files to leave out, relative to the root: `check` in folders and globs, the ESLint plugin, the Claude Code hook and check_ui leave them out, and finding components skips them. A folder (`app/legacy`) covers everything in it. Adds to the defaults (node_modules, .d.ts files, tests and stories); a pattern that starts with `!` takes out the default it names, such as `!**/*.d.ts`.",
       "type": "array",
       "items": {
         "type": "string"