onsystem 0.5.0 → 0.6.0

package/dist/eslint-worker.d.ts

@@ -1,4 +1,4 @@
-import { a as DesignSystemModel, x as ResolvedConfig } from "./types-DJtccu3A.js";
+import { h as DesignSystemModel, i as ResolvedConfig } from "./config-lbfW91qB.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 { B as DEFAULT_TEST_FOLDERS, i as componentFiles, it as relativePath, r as buildModel, rt as matchesGlob, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
-import { r as loadTarget } from "./workspace-DzWQ4L8R.js";
+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 fs from "node:fs";
 import path from "node:path";
 import { parentPort } from "node:worker_threads";
@@ -9,6 +9,8 @@ import { parentPort } from "node:worker_threads";
 * project's design system does not (config files written in code, globs, the extraction
 * cache), so the plugin asks this worker and waits for the answer (see `bridge.ts`).
 */
+/** What the configs said (a design-system package's skipped, or its paths ignored), each said once. */
+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();
@@ -44,6 +46,11 @@ async function targetFor({ cwd, root, config }) {
 async function load(request) {
 	const target = await targetFor(request);
 	const config = target.workspace ? (await target.workspace.projectFor(request.file)).config : target.config;
+	for (const text of config.warnings ?? []) {
+		if (warned.has(text)) continue;
+		warned.add(text);
+		process.stderr.write(`onsystem: ${text}\n`);
+	}
 	let project = projects.get(config.root);
 	if (!project || Date.now() - project.at >= FRESH_MS) {
 		const { model, key } = await buildModel(config, { cache: true });

package/dist/eslint.js

@@ -1,4 +1,4 @@
-import { B as DEFAULT_TEST_FOLDERS, R as DEFAULT_SEVERITY, T as RULES, _ as VERSION, g as NAME, it as relativePath, t as DesignSystem, z as DEFAULT_TEST_EXCLUDE } from "./design-system-CnEv5sIL.js";
+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 path from "node:path";
 import { MessageChannel, Worker, receiveMessageOnPort } from "node:worker_threads";
 //#region src/eslint/bridge.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { C as RuleId, D as loadConfig, E as defineConfig, O as ImportMapping, S as ResolvedRule, T as configJsonSchema, _ as VariantInfo, a as DesignSystemModel, b as RULE_IDS, c as ExampleInfo, d as Severity, f as SourceLocation, g as TokenCategory, h as Token, i as CompoundVariantInfo, l as InheritedProps, m as TextEdit, n as ComponentDocs, o as Diagnostic, p as TOKEN_CATEGORIES, r as ComponentInfo, s as DocSection, t as CheckResult, u as PropInfo, v as Config, w as RuleOptions, x as ResolvedConfig, y as LoadConfigOptions } from "./types-DJtccu3A.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-lbfW91qB.js";
 import ts from "typescript";
 import { Oklch } from "culori";
 import { McpServer, Transport } from "@modelcontextprotocol/server";
@@ -115,6 +115,12 @@ export declare function parseCssTokens(css: string, file: string): {
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/design-md.d.ts
+export declare function parseDesignMd(text: string, file: string): {
+  tokens: Token[];
+  warnings: string[];
+};
+//#endregion
 //#region src/tokens/dtcg.d.ts
 interface DtcgOptions {
   /** Prefix for generated custom property names: `ds` → `--ds-color-primary`. */
@@ -125,6 +131,34 @@ export declare function parseDtcgTokens(text: string, file: string, options?: Dt
   warnings: string[];
 };
 //#endregion
+//#region src/tokens/export.d.ts
+/**
+ * Writes the tokens onsystem found as a DTCG 2025.10 file or a DESIGN.md. Both are grouped by
+ * category; reading the DTCG file back gives the same tokens, with the same names.
+ */
+interface Exported {
+  text: string;
+  /** How many tokens were written. */
+  count: number;
+  /** Tokens left out, and why. */
+  warnings: string[];
+}
+/**
+ * The tokens as a DTCG 2025.10 file: a group per category, colors as color objects in their
+ * own color space, lengths as `{ value, unit }`, aliases as references, and what DTCG has no
+ * field for (the token's name, the custom property, the Tailwind theme variable, dark and
+ * other modes) under `$extensions["com.github.dgesteves.onsystem"]`.
+ */
+export declare function toDtcg(tokens: readonly Token[]): Exported;
+/**
+ * The tokens as a DESIGN.md: front matter with the colors, typography, rounded corners and
+ * spacing in the spec's schema, then a heading per category with a table of its tokens, their
+ * values in each mode and how code uses them.
+ */
+export declare function toDesignMd(tokens: readonly Token[], options: {
+  name: string;
+}): Exported;
+//#endregion
 //#region src/tokens/index.d.ts
 interface TokenSource {
   file: string;
@@ -261,6 +295,8 @@ declare class LintTarget {
   private readonly moduleDirs;
   /** The files extraction read, when the model says. */
   private readonly sources?;
+  /** Published libraries the model read from type declarations: `@mui/material`. */
+  readonly libraries: Set<string>;
   /**
    * `resolver` finds the module an import points at and what it exports
    * (`@calcom/ui/components/icon` → `components/icon/index.ts`), so a name from
@@ -316,6 +352,10 @@ declare class LintTarget {
   /** The component a module exports as `default`, for `import Anything from "..."`. */
   defaultExport(specifier: string, fromFile?: string): ComponentInfo | undefined;
   private resolveRelative;
+  /** The library an import specifier points into (`@mui/material/Button`), if any. */
+  libraryOf(specifier: string): string | undefined;
+  /** The library's own component of that name: `Button` from `@mui/material`, not a wrapper. */
+  libraryComponent(name: string, library: string): ComponentInfo | undefined;
   /** Component names for "did you mean" suggestions. */
   names(): string[];
 }
@@ -480,6 +520,12 @@ export declare class DesignSystem {
   readonly config: ResolvedConfig;
   readonly lint: LintTarget;
   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.
+   */
+  private readonly offered;
   constructor(model: DesignSystemModel, config: ResolvedConfig);
   get root(): string;
   get components(): ComponentInfo[];
@@ -498,6 +544,14 @@ export declare class DesignSystem {
   }): Token[];
   /** Tokens a component's classes and CSS variables reference, e.g. `bg-primary` → `primary`. */
   relatedTokens(component: ComponentInfo): Token[];
+  /**
+   * Whether `check --require-design-system` (and the GitHub Action, where it is on by default)
+   * finds a design system to check against: components and color tokens, or components from a
+   * published library (MUI). A library is the design system whatever its theme: when the theme's
+   * colors cannot be read (a palette from Sass variables), the check still runs and `notice()`
+   * says that no-hardcoded-color did not.
+   */
+  hasDesignSystem(): boolean;
   /**
    * What the rules could not check, when it matters: without components the
    * component rules find nothing, and without color tokens neither does

package/dist/index.js

@@ -1,3 +1,3 @@
-import { A as parseDtcgTokens, D as loadTokens, E as TokenIndex, G as loadConfig, H as RULE_IDS, M as attachDocs, N as parseDoc, O as mergeTokens, P as extractComponents, T as RULES, U as configJsonSchema, W as defineConfig, _ as VERSION, a as fingerprint, d as searchComponents, f as applyFixes, h as formatDiagnostics, j as parseCssTokens, n as DesignSystemHost, o as loadDesignSystem, p as checkSource, q as findVariantDefinitions, r as buildModel, t as DesignSystem } from "./design-system-CnEv5sIL.js";
-import { n as INSTRUCTIONS, r as createServer, t as serveStdio } from "./stdio-DjfkiDMV.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, parseDoc, parseDtcgTokens, searchComponents, serveStdio };
+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";
+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-DjfkiDMV.js → stdio-CEChNFLR.js}

@@ -1,26 +1,12 @@
-import { $ as plural, F as CONFIG_FILES, G as loadConfig, Q as closest, V as LEGACY_CONFIG_FILES, _ as VERSION, d as searchComponents, et as truncate, g as NAME, it as relativePath, k as formatPx, m as uncheckedNotice, n as DesignSystemHost, nt as isInside, tt as unique, u as buildSearchIndex } from "./design-system-CnEv5sIL.js";
-import { n as hasProjectMarker, r as loadTarget, t as findProjectRoot } from "./workspace-DzWQ4L8R.js";
+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 fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as z from "zod";
-import fs$1 from "node:fs/promises";
+import fsp from "node:fs/promises";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-//#region src/types.ts
-/**
-* The design-system model the server exposes. Everything here is plain JSON so
-* it can be cached on disk and returned as MCP structured content.
-*/
-const TOKEN_CATEGORIES = [
-	"color",
-	"spacing",
-	"radius",
-	"typography",
-	"shadow",
-	"other"
-];
-//#endregion
 //#region src/server/render.ts
 /**
 * Tool results are read by models, so they are rendered as compact Markdown:
@@ -44,15 +30,21 @@ function renderComponentList(ds, project) {
 	if (!roots.length) return `No components found${project ? ` in ${project}` : ""}. Check the "components" globs in the config (root: ${ds.root}).`;
 	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.`, ""];
-	for (const component of roots) lines.push(...listItem(component));
+	const own = roots.filter((c) => !c.library);
+	for (const component of own) lines.push(...listItem(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}"):`, "");
+		for (const component of roots.filter((c) => c.library === library)) lines.push(...listItem(component, "", false));
+	}
 	return lines.join("\n");
 }
-function listItem(component, note = "") {
+function listItem(component, note = "", withImport = true) {
 	const element = component.element ? ` <${component.element}>` : "";
 	const lines = [`${component.name}${element}${note} — ${firstSentence(component.description) || "No description."}`];
 	for (const variant of variantSummary(component)) lines.push(`  ${variant}`);
 	if (component.subcomponents.length) lines.push(`  parts: ${component.subcomponents.join(", ")}`);
-	lines.push(`  ${importStatement(component)}`);
+	if (withImport) lines.push(`  ${importStatement(component)}`);
 	return lines;
 }
 /** `apps/web`, `apps/web and packages/ui`, `a, b, c and 4 more`. */
@@ -191,6 +183,10 @@ function renderComponent(ds, component, origin) {
 	if (component.variants.length) {
 		lines.push("", "## Variants");
 		for (const variant of component.variants) {
+			if (!Object.values(variant.classes).some(Boolean)) {
+				lines.push(`${variant.name}: ${variant.values.join(" | ")}${variant.default ? ` (default "${variant.default}")` : ""}`);
+				continue;
+			}
 			lines.push(`${variant.name}${variant.default ? ` (default "${variant.default}")` : ""}`);
 			const width = Math.max(...variant.values.map((v) => v.length));
 			for (const value of variant.values) lines.push(`  ${value.padEnd(width)}  ${variant.classes[value] ?? ""}`.trimEnd());
@@ -848,16 +844,16 @@ function createServer({ getDesignSystem, getProjects }) {
 			const outside = errorResult(`${filePath} is outside the project root (${base}).`);
 			if (!isInside(base, absolute)) return outside;
 			try {
-				const [root, real] = await Promise.all([fs$1.realpath(base), fs$1.realpath(absolute)]);
+				const [root, real] = await Promise.all([fsp.realpath(base), fsp.realpath(absolute)]);
 				if (!isInside(root, real)) return outside;
-				if ((await fs$1.stat(real)).size > MAX_CODE) return {
+				if ((await fsp.stat(real)).size > MAX_CODE) return {
 					isError: true,
 					content: [{
 						type: "text",
 						text: `${filePath} is too large to check.`
 					}]
 				};
-				source = await fs$1.readFile(real, "utf8");
+				source = await fsp.readFile(real, "utf8");
 			} catch {
 				return {
 					isError: true,
@@ -1035,7 +1031,7 @@ var Catalog = class {
 			byKey.set(key, {
 				component: rebase(component, root, file),
 				ds,
-				package: owner(file),
+				package: component.library ?? owner(file),
 				projects: [dir],
 				ambiguous: false
 			});
@@ -1265,6 +1261,7 @@ function serveStdio$1(options) {
 		};
 		const { config, workspace } = await loadTarget(configOptions);
 		for (const text of config.deprecations ?? []) logger.warn(text);
+		for (const text of (workspace ? workspace.warnings : config.warnings) ?? []) logger.warn(text);
 		if (workspace) {
 			const projects = new WorkspaceProjects(workspace, {
 				cache: options.cache,

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

@@ -1,4 +1,4 @@
-import { F as CONFIG_FILES, G as loadConfig, V as LEGACY_CONFIG_FILES, X as workspacePackageDirs, Y as isWorkspaceRoot, Z as workspacePatterns, i as componentFiles, it as relativePath, nt as isInside } from "./design-system-CnEv5sIL.js";
+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 fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -18,7 +18,8 @@ const PROJECT_MARKERS = [
 ];
 /**
 * A monorepo seen from its root: every workspace package with a design system (an app
-* that uses one, or the design-system package itself), and how to find the project of
+* that uses one, from source or a published library, or the design-system package
+* itself), and how to find the project of
 * any file in it. Without a design system at the root, `check`, `inspect` and the MCP
 * server work from here, each file checked by its own project's design system.
 */
@@ -30,8 +31,9 @@ var Workspace = class {
 	configFile;
 	options;
 	rootConfig;
+	otherConfigs;
 	bare = /* @__PURE__ */ new Map();
-	constructor(root, source, projects, others, configFile, options, rootConfig) {
+	constructor(root, source, projects, others, configFile, options, rootConfig, otherConfigs = []) {
 		this.root = root;
 		this.source = source;
 		this.projects = projects;
@@ -39,6 +41,19 @@ var Workspace = class {
 		this.configFile = configFile;
 		this.options = options;
 		this.rootConfig = rootConfig;
+		this.otherConfigs = otherConfigs;
+	}
+	/**
+	* What the configs of the workspace's packages have to say ({@link ResolvedConfig.warnings}),
+	* each once, as they were read when the workspace was found.
+	*/
+	get warnings() {
+		const configs = [
+			this.rootConfig,
+			...this.projects.map((p) => p.config),
+			...this.otherConfigs
+		];
+		return [...new Set(configs.flatMap((c) => c.warnings ?? []))];
 	}
 	/**
 	* The project `target` (a file or a folder) belongs to: the nearest folder at or above
@@ -102,24 +117,31 @@ async function discoverWorkspace(rootConfig, options) {
 	].filter(Boolean).join(", ");
 	const projects = [];
 	const others = [];
+	const otherConfigs = [];
 	for (const dir of workspacePackageDirs(root)) {
 		const config = await loadProjectConfig(dir, root, rootConfig.configFile, options);
 		const files = (await componentFiles(config)).length;
 		const own = config.configFile !== void 0 && config.configFile !== rootConfig.configFile;
-		if (files || own) projects.push({
+		const library = config.libraries?.some((l) => l.dir !== void 0) ?? false;
+		if (files || own || library) projects.push({
 			root: dir,
 			dir: relativePath(root, dir),
 			name: packageName(dir),
 			config,
 			componentFiles: files
 		});
-		else others.push(relativePath(root, dir));
+		else {
+			others.push(relativePath(root, dir));
+			if (config.warnings) otherConfigs.push(config);
+		}
 	}
-	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig);
+	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig, otherConfigs);
 }
 /**
-* A project's config: its own config file, or the workspace root's, with paths relative to
-* the workspace root, or zero config. CLI flags that apply to every project carry over.
+* A project's config: its own config file, else the config its design-system package declares
+* (a dependency with `"onsystem"` in its package.json), else the workspace root's, with paths
+* relative to the workspace root, else zero config. `loadConfig` from the project's folder finds
+* the first two the same way. CLI flags that apply to every project carry over.
 */
 function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
 	const shared = {
@@ -127,15 +149,27 @@ function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
 		includeDesignSystem: options.includeDesignSystem,
 		jsonConfigOnly: options.jsonConfigOnly
 	};
-	if ([...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((name) => fs.existsSync(path.join(dir, name))) || !rootConfigFile) return loadConfig({
+	const packages = new PackageFinder(dir);
+	if (!rootConfigFile || hasOwnConfig(dir)) return loadConfigWith({
+		...shared,
+		root: dir
+	}, { packages });
+	const lookup = findDesignSystemPackage(dir, packages);
+	if (lookup?.found || lookup?.problems.length) return loadConfigWith({
 		...shared,
 		root: dir
+	}, {
+		packages,
+		lookup
 	});
-	return loadConfig({
+	return loadConfigWith({
 		...shared,
 		root: dir,
 		config: rootConfigFile,
 		base: workspaceRoot
+	}, {
+		packages,
+		lookup
 	});
 }
 /** The nearest folder at or above `target` (a file or folder) with a project marker, up to `root`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onsystem",
-  "version": "0.5.0",
+  "version": "0.6.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.",
   "keywords": [
@@ -25,7 +25,7 @@
     "mcp",
     "model-context-protocol"
   ],
-  "homepage": "https://github.com/dgesteves/onsystem#readme",
+  "homepage": "https://onsystem.vercel.app",
   "bugs": "https://github.com/dgesteves/onsystem/issues",
   "repository": {
     "type": "git",
@@ -68,6 +68,7 @@
     "stemmer": "^2.0.1",
     "tinyglobby": "^0.2.17",
     "typescript": "~6.0.3",
+    "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },
   "peerDependencies": {

package/schema.json

@@ -29,7 +29,7 @@
       }
     },
     "tokens": {
-      "description": "Token files: W3C DTCG JSON (*.json) or CSS custom properties (*.css).",
+      "description": "Token files: W3C DTCG JSON (*.json), CSS custom properties (*.css) or a DESIGN.md's front matter (*.md).",
       "anyOf": [
         {
           "anyOf": [
@@ -116,6 +116,24 @@
         "type": "string"
       }
     },
+    "libraries": {
+      "description": "Published component libraries to read from their type declarations when the project depends on them. Omitted: every one onsystem reads (mui). false: none. A list: only those, e.g. [\"mui\"].",
+      "anyOf": [
+        {
+          "type": "boolean",
+          "const": false
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "mui"
+            ]
+          }
+        }
+      ]
+    },
     "includeDesignSystem": {
       "description": "check: lint the design system's own component files too. Off by default: they implement the scale and primitives the rules enforce.",
       "type": "boolean"