onsystem 0.0.1 → 0.5.0

package/dist/types-DJtccu3A.d.ts

@@ -0,0 +1,386 @@
+import * as z from "zod";
+//#region src/detect.d.ts
+/**
+ * How apps import a design-system module, from a package's `exports`:
+ * `@midday/ui/button` → `../../packages/ui/src/components/button.tsx`, or a
+ * pattern (`@workspace/ui/components/*` → `…/src/components/*.tsx`). A
+ * specifier without `*` and a pattern target map every matching file to one
+ * module: a package that exports its components from a barrel.
+ */
+interface ImportMapping {
+  specifier: string;
+  /** File or pattern relative to the root, with forward slashes. */
+  target: string;
+}
+/** One of several design systems an app uses, and how often its code imports it. */
+interface DesignSystemSource {
+  source: string;
+  components: string[];
+  imports: number;
+}
+//#endregion
+//#region src/config.d.ts
+declare const RULE_IDS: readonly ["no-hardcoded-color", "no-hardcoded-spacing", "no-hardcoded-radius", "prefer-design-system-component", "no-unknown-component", "no-unknown-prop", "no-unknown-variant", "icon-button-accessible-name"];
+type RuleId = (typeof RULE_IDS)[number];
+declare const severitySchema: z.ZodEnum<{
+  off: "off";
+  warn: "warn";
+  error: "error";
+}>;
+type RuleSeverity = z.infer<typeof severitySchema>;
+declare const ruleOptionsSchema: z.ZodObject<{
+  allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type RuleOptions = z.infer<typeof ruleOptionsSchema>;
+declare const configSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  components: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  tokens: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    prefix: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>]>>;
+  docs: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+  tsconfig: z.ZodOptional<z.ZodString>;
+  importPath: z.ZodOptional<z.ZodString>;
+  elements: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  includeDesignSystem: z.ZodOptional<z.ZodBoolean>;
+  rules: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+    "no-hardcoded-color": "no-hardcoded-color";
+    "no-hardcoded-spacing": "no-hardcoded-spacing";
+    "no-hardcoded-radius": "no-hardcoded-radius";
+    "prefer-design-system-component": "prefer-design-system-component";
+    "no-unknown-component": "no-unknown-component";
+    "no-unknown-prop": "no-unknown-prop";
+    "no-unknown-variant": "no-unknown-variant";
+    "icon-button-accessible-name": "icon-button-accessible-name";
+  }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
+    off: "off";
+    warn: "warn";
+    error: "error";
+  }>, z.ZodTuple<[z.ZodEnum<{
+    off: "off";
+    warn: "warn";
+    error: "error";
+  }>], null>, z.ZodTuple<[z.ZodEnum<{
+    off: "off";
+    warn: "warn";
+    error: "error";
+  }>, z.ZodObject<{
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>], null>]>>>;
+  overrides: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    files: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    rules: z.ZodRecord<z.ZodEnum<{
+      "no-hardcoded-color": "no-hardcoded-color";
+      "no-hardcoded-spacing": "no-hardcoded-spacing";
+      "no-hardcoded-radius": "no-hardcoded-radius";
+      "prefer-design-system-component": "prefer-design-system-component";
+      "no-unknown-component": "no-unknown-component";
+      "no-unknown-prop": "no-unknown-prop";
+      "no-unknown-variant": "no-unknown-variant";
+      "icon-button-accessible-name": "icon-button-accessible-name";
+    }> & z.core.$partial, z.ZodUnion<readonly [z.ZodEnum<{
+      off: "off";
+      warn: "warn";
+      error: "error";
+    }>, z.ZodTuple<[z.ZodEnum<{
+      off: "off";
+      warn: "warn";
+      error: "error";
+    }>], null>, z.ZodTuple<[z.ZodEnum<{
+      off: "off";
+      warn: "warn";
+      error: "error";
+    }>, z.ZodObject<{
+      allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>], null>]>>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type Config = z.input<typeof configSchema>;
+/** Identity helper for typed `onsystem.config.ts` files. */
+declare function defineConfig(config: Config): Config;
+interface TokenSourceConfig {
+  path: string;
+  prefix?: string | undefined;
+}
+interface ResolvedRule {
+  severity: RuleSeverity;
+  options: RuleOptions;
+}
+/** Rule settings for the files that match `files` (root-relative globs). */
+interface ResolvedOverride {
+  files: string[];
+  rules: Partial<Record<RuleId, ResolvedRule>>;
+}
+interface ResolvedConfig {
+  root: string;
+  configFile?: string | undefined;
+  components: string[];
+  exclude: string[];
+  tokens: TokenSourceConfig[];
+  docs: string[];
+  tsconfig?: string | undefined;
+  importPath?: string | undefined;
+  /** Import specifiers for component files, from the `exports` of the package that holds them. */
+  imports?: ImportMapping[] | undefined;
+  /** How the design system was found when the config does not say (`components.json`, a workspace package). */
+  detected?: string | undefined;
+  /**
+   * Several design systems found at once, the most imported first: its components win
+   * where two share a name, and are the ones suggested for native elements.
+   */
+  designSystems?: DesignSystemSource[] | undefined;
+  /** A Tailwind v3 config, which maps color classes to custom properties (`primary` → `hsl(var(--primary))`). */
+  tailwindConfig?: string | undefined;
+  elements: Record<string, string>;
+  /** `check` lints the component files themselves, which it skips by default. */
+  includeDesignSystem: boolean;
+  rules: Record<RuleId, ResolvedRule>;
+  /** Per-file rule settings, applied in order over `rules`. */
+  overrides?: ResolvedOverride[] | undefined;
+  /**
+   * The folder `overrides` globs are relative to, when it is not the root: the workspace
+   * root, for a project that takes its settings from a config there.
+   */
+  base?: string | undefined;
+  /** `components` comes from the config file or `--components`, not from detection or the defaults. */
+  configured?: boolean | undefined;
+  /**
+   * What to tell the user about the config's name: a config file found under its name from
+   * before the rename to onsystem. The CLI prints these once per run, the server logs them once.
+   */
+  deprecations?: string[] | undefined;
+}
+interface LoadConfigOptions {
+  /** Where to look for a config file when `root` and `config` are not given. */
+  cwd?: string;
+  /** Project root. Defaults to the config file's directory, then `cwd`. */
+  root?: string | undefined;
+  /** Explicit config file path. */
+  config?: string | undefined;
+  /**
+   * The folder the config file's paths and globs are written relative to, when it is not
+   * the root: a workspace root whose config a project in it takes on.
+   */
+  base?: string | undefined;
+  /** CLI overrides; replace the config file's values when set. */
+  components?: string[] | undefined;
+  tokens?: string[] | undefined;
+  docs?: string[] | undefined;
+  includeDesignSystem?: boolean | undefined;
+  /**
+   * Read a JSON config only: a JavaScript or TypeScript config is an error rather than run.
+   * For a project the MCP server found from the path a tool call names, which a prompt can
+   * choose, unlike the folder the server was started in.
+   */
+  jsonConfigOnly?: boolean | undefined;
+}
+declare function loadConfig(options?: LoadConfigOptions): Promise<ResolvedConfig>;
+/** JSON Schema for editor completion in `onsystem.config.json`. */
+declare function configJsonSchema(): Record<string, unknown>;
+//#endregion
+//#region src/types.d.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.
+ */
+declare const TOKEN_CATEGORIES: readonly ["color", "spacing", "radius", "typography", "shadow", "other"];
+type TokenCategory = (typeof TOKEN_CATEGORIES)[number];
+interface SourceLocation {
+  /** Path relative to the project root, with forward slashes. */
+  file: string;
+  /** 1-based line. */
+  line: number;
+}
+interface Token {
+  /**
+   * Canonical name: the DTCG path for JSON tokens (`color.brand.500`) or the
+   * custom property without its dashes for CSS tokens (`primary`, `radius-md`).
+   */
+  name: string;
+  category: TokenCategory;
+  /** The value with aliases resolved, as authored (`oklch(0.205 0 0)`, `0.5rem`). */
+  value: string;
+  /** Values for other modes or themes, e.g. `{ dark: "oklch(0.922 0 0)" }`. */
+  modes?: Record<string, string>;
+  /** The custom property to reference from CSS, e.g. `--primary`. */
+  cssVar?: string;
+  /**
+   * Tailwind theme key when the token is exposed through `@theme`
+   * (`primary` for `--color-primary`, `md` for `--radius-md`).
+   */
+  tailwind?: string;
+  /** Ready-to-paste usages, most idiomatic first: `bg-primary`, `var(--primary)`. */
+  usage: string[];
+  description?: string;
+  deprecated?: string | true;
+  /** Name of the token this one aliases, if any. */
+  aliasOf?: string;
+  /** Where the value comes from. `tailwind-default` marks Tailwind built-ins such as `--spacing`. */
+  origin?: 'tailwind-default';
+  source: SourceLocation;
+}
+interface PropInfo {
+  name: string;
+  /** TypeScript type as written by the checker, without `| undefined`. */
+  type: string;
+  required: boolean;
+  default?: string;
+  description?: string;
+  /** Allowed values when the type is a finite set of literals. */
+  values?: string[];
+  deprecated?: string | true;
+  /** `variant` when the prop comes from a `cva()` definition. */
+  kind: 'prop' | 'variant';
+}
+interface VariantInfo {
+  /** Variant prop name, e.g. `variant` or `size`. */
+  name: string;
+  values: string[];
+  default?: string;
+  /** Classes applied for each value, straight from the `cva()` config. */
+  classes: Record<string, string>;
+}
+interface CompoundVariantInfo {
+  when: Record<string, string | string[]>;
+  classes: string;
+}
+interface InheritedProps {
+  /** Source text of the type the props come from, e.g. `React.ComponentProps<"button">`. */
+  from: string;
+  count: number;
+  /** Key into `DesignSystemModel.propSets` with the full list of names. */
+  set: string;
+  /** Names in the set marked `@deprecated` (React Aria's `onClick`), left out of summaries. */
+  deprecated?: string[];
+}
+interface ExampleInfo {
+  title?: string;
+  code: string;
+  lang: string;
+  source: 'docs' | 'jsdoc';
+}
+interface DocSection {
+  heading: string;
+  body: string;
+}
+interface ComponentDocs {
+  file: string;
+  description?: string;
+  sections: DocSection[];
+  frontmatter: Record<string, string | string[]>;
+}
+interface ComponentInfo {
+  /** How the component is referenced in JSX: `Button`, `CardHeader` or `Tabs.List`. */
+  name: string;
+  /** Other names that resolve to the same component (e.g. `Card.Header` when `CardHeader` is also exported). */
+  aliases: string[];
+  description?: string;
+  deprecated?: string | true;
+  /** Suggested import specifier, e.g. `@/components/ui/button`. */
+  importPath: string;
+  /** Exported binding name, or the static member path for compound members. */
+  exportName: string;
+  source: SourceLocation;
+  /** The root component this one belongs to (`Card` for `CardHeader`). */
+  parent?: string;
+  /** Direct sub-components, in declaration order. */
+  subcomponents: string[];
+  /** Native element it renders or wraps, when it can be inferred (`button`, `input`). */
+  element?: string;
+  props: PropInfo[];
+  inherits: InheritedProps[];
+  /**
+   * True when part of the props type could not be resolved (missing
+   * `node_modules`, a type error). The linter then skips unknown-prop checks.
+   */
+  openProps: boolean;
+  variants: VariantInfo[];
+  compoundVariants: CompoundVariantInfo[];
+  examples: ExampleInfo[];
+  docs?: ComponentDocs;
+  /** Utility classes used in the component source; mapped to tokens at query time. */
+  classNames: string[];
+  /** CSS custom properties referenced in the component source. */
+  cssVars: string[];
+}
+interface DesignSystemModel {
+  version: 1;
+  root: string;
+  components: ComponentInfo[];
+  tokens: Token[];
+  /** Shared inherited prop-name lists, deduplicated across components. */
+  propSets: Record<string, string[]>;
+  /**
+   * Every value the component files export, components or not (`Icons`,
+   * `buttonVariants`), so the linter tells an invented name from a real export.
+   */
+  exports: string[];
+  /** Non-fatal problems found while extracting (unparseable files, unmatched docs). */
+  warnings: string[];
+  /**
+   * The component files extraction read, relative to the root: a name one of them exports
+   * that is not a component was seen, while a file outside them was never looked at.
+   */
+  sources?: string[];
+  stats: {
+    files: {
+      components: number;
+      tokens: number;
+      docs: number;
+    };
+    durationMs: number;
+    fromCache: boolean;
+  };
+}
+type Severity = 'error' | 'warning';
+interface TextEdit {
+  /** 0-based offsets into the checked source, end exclusive. */
+  range: [number, number];
+  text: string;
+}
+interface Diagnostic {
+  ruleId: string;
+  severity: Severity;
+  message: string;
+  /** 1-based. */
+  line: number;
+  /** 1-based. */
+  column: number;
+  endLine: number;
+  endColumn: number;
+  /** The offending source text. */
+  source: string;
+  /** What to write instead, e.g. `bg-destructive` or `<Button>`. */
+  suggestion?: string;
+  /** Edits that apply the suggestion, when it can be done mechanically. */
+  fix?: TextEdit[];
+}
+interface CheckResult {
+  file: string;
+  diagnostics: Diagnostic[];
+  errorCount: number;
+  warningCount: number;
+  /** With a baseline: findings it accepted, left out of `diagnostics` and the counts. */
+  baselined?: number;
+  /**
+   * Components imported from design-system modules the model does not include
+   * (extraction is incomplete), which the rules could not check.
+   */
+  unchecked?: {
+    names: string[];
+    modules: string[];
+  };
+  /**
+   * Why the file was not checked: it renders outside the browser's CSS (an
+   * Open Graph image through next/og, an email through React Email), where
+   * design tokens and classes do not apply.
+   */
+  skipped?: string;
+}
+//#endregion
+export { RuleId as C, loadConfig as D, defineConfig as E, ImportMapping as O, ResolvedRule as S, configJsonSchema as T, VariantInfo as _, DesignSystemModel as a, RULE_IDS as b, ExampleInfo as c, Severity as d, SourceLocation as f, TokenCategory as g, Token as h, CompoundVariantInfo as i, InheritedProps as l, TextEdit as m, ComponentDocs as n, Diagnostic as o, TOKEN_CATEGORIES as p, ComponentInfo as r, DocSection as s, CheckResult as t, PropInfo as u, Config as v, RuleOptions as w, ResolvedConfig as x, LoadConfigOptions as y };

package/dist/workspace-DzWQ4L8R.js

@@ -0,0 +1,193 @@
+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 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, 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;
+	bare = /* @__PURE__ */ new Map();
+	constructor(root, source, projects, others, configFile, options, rootConfig) {
+		this.root = root;
+		this.source = source;
+		this.projects = projects;
+		this.others = others;
+		this.configFile = configFile;
+		this.options = options;
+		this.rootConfig = rootConfig;
+	}
+	/**
+	* 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 = [];
+	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({
+			root: dir,
+			dir: relativePath(root, dir),
+			name: packageName(dir),
+			config,
+			componentFiles: files
+		});
+		else others.push(relativePath(root, dir));
+	}
+	return new Workspace(root, source, projects, others, rootConfig.configFile, options, rootConfig);
+}
+/**
+* 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.
+*/
+function loadProjectConfig(dir, workspaceRoot, rootConfigFile, options) {
+	const shared = {
+		cwd: options.cwd,
+		includeDesignSystem: options.includeDesignSystem,
+		jsonConfigOnly: options.jsonConfigOnly
+	};
+	if ([...CONFIG_FILES, ...LEGACY_CONFIG_FILES].some((name) => fs.existsSync(path.join(dir, name))) || !rootConfigFile) return loadConfig({
+		...shared,
+		root: dir
+	});
+	return loadConfig({
+		...shared,
+		root: dir,
+		config: rootConfigFile,
+		base: workspaceRoot
+	});
+}
+/** 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 };