onsystem 0.4.0 → 0.6.0

package/dist/workspace-CHvUwgz9.js

@@ -0,0 +1,227 @@
+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";
+//#region src/workspace.ts
+/**
+* What marks the folder a file belongs to: the nearest one at or above it with a config,
+* a components.json, a package.json or an Nx project.json. The Claude Code hook finds a
+* file's project the same way, so `check` from a workspace root and the hook agree on
+* every file.
+*/
+const PROJECT_MARKERS = [
+	...CONFIG_FILES,
+	...LEGACY_CONFIG_FILES,
+	"components.json",
+	"package.json",
+	"project.json"
+];
+/**
+* A monorepo seen from its root: every workspace package with a design system (an app
+* 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.
+*/
+var Workspace = class {
+	root;
+	source;
+	projects;
+	others;
+	configFile;
+	options;
+	rootConfig;
+	otherConfigs;
+	bare = /* @__PURE__ */ new Map();
+	constructor(root, source, projects, others, configFile, options, rootConfig, otherConfigs = []) {
+		this.root = root;
+		this.source = source;
+		this.projects = projects;
+		this.others = others;
+		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
+	* it with one of the `PROJECT_MARKERS`, as the hook finds it, up to the workspace root. A folder that holds no design system still gets
+	* its config, so its files are checked as `check` from that folder would check them.
+	*/
+	async projectFor(target) {
+		const dir = projectDirOf(path.resolve(this.root, target), this.root);
+		const known = this.projects.find((p) => p.root === dir);
+		if (known) return known;
+		let project = this.bare.get(dir);
+		if (!project) {
+			project = dir === this.root ? Promise.resolve(this.rootProject()) : this.load(dir);
+			this.bare.set(dir, project);
+		}
+		return project;
+	}
+	rootProject() {
+		return {
+			root: this.root,
+			dir: ".",
+			name: packageName(this.root),
+			config: this.rootConfig
+		};
+	}
+	/** A project's config read again, as `check` from its folder would read it. */
+	configFor(project) {
+		return project.root === this.root ? loadConfig(this.options) : loadProjectConfig(project.root, this.root, this.configFile, this.options);
+	}
+	async load(dir) {
+		return {
+			root: dir,
+			dir: relativePath(this.root, dir) || ".",
+			name: packageName(dir),
+			config: await loadProjectConfig(dir, this.root, this.configFile, this.options)
+		};
+	}
+};
+/**
+* The config at `root`, or a `Workspace` when `root` is a monorepo root with no design
+* system of its own. The root is one project, as before, when a config file or
+* `--components` sets the components, when `--config`, `--tokens` or `--docs` is given,
+* or when zero config finds a design system there.
+*/
+async function loadTarget(options) {
+	const config = await loadConfig(options);
+	if (options.config !== void 0 || Boolean(options.components?.length) || Boolean(options.tokens?.length) || Boolean(options.docs?.length) || config.configured || !isWorkspaceRoot(config.root)) return { config };
+	if (config.detected !== void 0 || (await componentFiles(config)).length) return { config };
+	return {
+		config,
+		workspace: await discoverWorkspace(config, options)
+	};
+}
+/** Every workspace package with a design system, and the rest by folder. */
+async function discoverWorkspace(rootConfig, options) {
+	const { root } = rootConfig;
+	const source = [
+		workspacePatterns(root).source,
+		fs.existsSync(path.join(root, "nx.json")) ? "nx.json" : "",
+		fs.existsSync(path.join(root, "turbo.json")) ? "turbo.json" : ""
+	].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;
+		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));
+			if (config.warnings) otherConfigs.push(config);
+		}
+	}
+	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig, otherConfigs);
+}
+/**
+* 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 = {
+		cwd: options.cwd,
+		includeDesignSystem: options.includeDesignSystem,
+		jsonConfigOnly: options.jsonConfigOnly
+	};
+	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 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`. */
+function projectDirOf(target, root) {
+	let dir = isDirectory(target) ? target : path.dirname(target);
+	while (isInside(root, dir) && dir !== root) {
+		if (hasProjectMarker(dir)) return dir;
+		dir = path.dirname(dir);
+	}
+	return root;
+}
+/**
+* The folder to serve `target` (an absolute file or folder, which need not exist yet) from,
+* found by walking up from it: the nearest folder with a project marker, as the Claude Code
+* hook finds a file's project, or the monorepo root above that folder when there is one, as
+* a client that reports the repository as its workspace would have the server started.
+* `loadTarget` there serves the root's own design system, or each project in it. The home
+* folder and the filesystem root are never one. Undefined when no other folder up to the
+* filesystem root has a project marker.
+*/
+function findProjectRoot(target, home = os.homedir()) {
+	const skipped = (dir) => dir === path.dirname(dir) || samePath(dir, home);
+	let dir = isDirectory(target) ? target : path.dirname(target);
+	while (skipped(dir) || !hasProjectMarker(dir)) {
+		const parent = path.dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+	for (let up = dir; up !== path.dirname(up); up = path.dirname(up)) if (!skipped(up) && isWorkspaceRoot(up)) return up;
+	return dir;
+}
+function samePath(a, b) {
+	return path.relative(path.resolve(a), path.resolve(b)) === "";
+}
+/** Whether `dir` holds one of the `PROJECT_MARKERS`. */
+function hasProjectMarker(dir) {
+	return PROJECT_MARKERS.some((name) => fs.existsSync(path.join(dir, name)));
+}
+function packageName(dir) {
+	try {
+		const name = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).name;
+		return typeof name === "string" ? name : void 0;
+	} catch {
+		return;
+	}
+}
+function isDirectory(target) {
+	try {
+		return fs.statSync(target).isDirectory();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { hasProjectMarker as n, loadTarget as r, findProjectRoot as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onsystem",
-  "version": "0.4.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": [
@@ -9,6 +9,8 @@
     "agent-guardrails",
     "linter",
     "lint",
+    "eslint",
+    "eslint-plugin",
     "react",
     "shadcn",
     "cva",
@@ -23,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",
@@ -37,6 +39,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./eslint": {
+      "types": "./dist/eslint.d.ts",
+      "default": "./dist/eslint.js"
+    },
     "./schema.json": "./schema.json",
     "./package.json": "./package.json"
   },
@@ -62,8 +68,17 @@
     "stemmer": "^2.0.1",
     "tinyglobby": "^0.2.17",
     "typescript": "~6.0.3",
+    "yaml": "^2.9.1",
     "zod": "^4.6.5"
   },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.3",
@@ -72,8 +87,12 @@
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@types/culori": "^4.0.1",
     "@types/node": "^24.19.1",
+    "ajv": "^8.20.0",
+    "ajv-draft-04": "^1.0.0",
+    "ajv-formats": "^3.0.1",
     "eslint": "^10.12.0",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-v9": "npm:eslint@9.39.5",
     "geist": "^1.7.2",
     "globals": "^17.13.0",
     "opentype.js": "^2.0.0",
@@ -98,6 +117,7 @@
     "pack-test": "node scripts/pack-test.mjs",
     "assets": "node scripts/build-assets.mjs",
     "palette": "node scripts/build-palette.mjs",
+    "sync-plugins": "node scripts/sync-plugins.mjs",
     "corpus": "node scripts/corpus.mjs",
     "demo:check": "cd examples/shadcn-demo && node ../../dist/cli.js check \"app/**/*.tsx\"",
     "demo:inspect": "node dist/cli.js inspect --root examples/shadcn-demo",

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"