@ng-solid/mcp 22.0.0

package/data/skills/ns-solid-theming/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: ns-solid-theming
+description: Work with the Arvisfy three-tier token architecture in @ng-solid/design-system — extending the preset, validating tokens and switching color scheme at runtime.
+---
+
+# Theming con Arvisfy
+
+## Los tres niveles de tokens
+
+`packages/design-system/src/lib/theme/presets/arvisfy.preset.ts` define el
+preset en tres tiers, cada uno sólo puede referenciar al tier anterior:
+
+1. **`primitive`** — únicos valores crudos permitidos (hex, `rem`, pesos de
+   fuente, escalas numéricas). Ejemplo real: `primitive.color.klein.500 =
+'#3665F3'`.
+2. **`semantic`** — referencia primitivos con la sintaxis `{primitive.…}`, y
+   se divide en `common` (independiente de esquema) y
+   `colorScheme.light` / `colorScheme.dark` (un valor distinto por esquema).
+3. **`components`** — referencia semánticos con `{semantic.…}`. Es el único
+   tier que las hojas de estilo de componente pueden consumir, y sólo a
+   través de la variable CSS resultante.
+
+Conteo actual del preset Arvisfy:
+
+157 primitivos, 265 semánticos, 693 de componente en 43 grupos.
+
+## Regla de oro del SCSS de componente
+
+El SCSS de un componente **sólo** puede leer variables `--ns-component-*`.
+Nunca `--ns-primitive-*` ni `--ns-semantic-*` directamente, y nunca un valor
+crudo (hex, `rgb()`, `px`/`rem`/`ms` literal) — eso lo enforcea
+`pnpm quality:styles` (ver la skill `ns-solid-style-contract`).
+
+La conversión de un path de token a variable CSS es determinista
+(`tokenPathToCssVariable` en `theme.utils.ts`): camelCase se separa en
+kebab-case y los puntos se vuelven guiones, con el tier como prefijo:
+
+```
+tier: 'component', path: 'button.background'
+  -> --ns-component-button-background
+```
+
+## Extender el preset — nunca copiarlo
+
+```ts
+import { Arvisfy, defineNsPreset } from '@ng-solid/design-system';
+
+export const ProductTheme = defineNsPreset(Arvisfy, {
+  name: 'product',
+  primitive: {
+    color: { brand: { 500: '#0052ff' } }
+  },
+  semantic: {
+    colorScheme: {
+      light: { color: { primary: '{primitive.color.brand.500}' } },
+      dark: { color: { primary: '{primitive.color.brand.500}' } }
+    }
+  },
+  components: {
+    button: { borderColor: '{semantic.color.primary}' }
+  }
+});
+```
+
+`defineNsPreset(base, overrides)` hace un merge profundo (`overrides` gana
+por clave) y llama a `validateNsPreset` sobre el resultado antes de
+devolverlo. `NsThemeService` también valida el preset activo en su
+constructor y en cada `setPreset`.
+
+## Reglas que aplica `validateNsPreset`
+
+Extraídas de `packages/design-system/src/lib/theme/utils/theme.utils.ts`:
+
+- **Nombre del preset**: debe matchear `/^[a-z][a-z0-9-]*$/i` (falla si no).
+- **Claves de token**: cada segmento del path debe matchear
+  `/^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/` — sin guiones ni mayúsculas iniciales.
+- **Valores primitivos seguros**: ningún string primitivo puede contener
+  `;`, `{` o `}`, ni estar vacío.
+- **Referencias `semantic.*`**: todo valor de `semantic.common` /
+  `semantic.colorScheme.{light,dark}` debe tener la forma exacta
+  `{primitive.<path>}` y ese `<path>` debe existir en `primitive`.
+- **Referencias `components.*`**: todo valor debe tener la forma
+  `{semantic.<path>}`, y ese `<path>` debe existir en `semantic.common`, o
+  en **ambos** `colorScheme.light` y `colorScheme.dark` a la vez — un token
+  de componente que sólo resuelve en un esquema es un preset inválido.
+
+Cualquier violación lanza una excepción síncrona (`throw new Error(...)`),
+no un warning: un preset inválido rompe el arranque de la app.
+
+## Cambiar de esquema en runtime
+
+```ts
+import { inject } from '@angular/core';
+import { NsThemeService } from '@ng-solid/design-system';
+
+const theme = inject(NsThemeService);
+theme.setScheme('dark'); // 'light' | 'dark' | 'system'
+```
+
+- `'system'` delega en `prefers-color-scheme` y reacciona a cambios en vivo
+  vía `matchMedia('(prefers-color-scheme: dark)')`.
+- Una elección explícita (`'light'` / `'dark'`) se persiste en
+  `localStorage` bajo la clave `ns-color-scheme` (configurable con
+  `provideNsTheme({ storageKey: '...' })`, o desactivable con
+  `storageKey: false`).
+- `NsThemeService` expone `preset`, `colorScheme`, `resolvedColorScheme`
+  (siempre `'light' | 'dark'`, nunca `'system'`) y `scheme` como signals de
+  sólo lectura.
+- Al aplicar el tema, el servicio escribe todas las custom properties en
+  `documentElement.style` y además `dataset.nsPreset` / `dataset.nsColorScheme`
+  y `style.colorScheme`, para que el navegador ajuste scrollbars/controles
+  nativos.
+
+## Configurar el provider
+
+```ts
+provideNsTheme({
+  preset: Arvisfy,
+  colorScheme: 'system', // default
+  storageKey: 'ns-color-scheme', // default; false para desactivar persistencia
+  toast: { placement: 'top-end' } // default de NsToastService
+});
+```

package/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export { createNsSolidMcpServer, runNsSolidMcpServer } from './lib/server.js';
+export type * from './lib/types.js';

package/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+export { createNsSolidMcpServer, runNsSolidMcpServer } from './lib/server.js';
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { runNsSolidMcpServer } from './lib/server.js';
+function realpathOrUndefined(path) {
+    if (!path)
+        return undefined;
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function main() {
+    const command = process.argv[2];
+    if (!command || command === 'serve') {
+        await runNsSolidMcpServer();
+        return;
+    }
+    if (command === 'install-skills') {
+        const { installSkills } = await import('./lib/install-skills.js');
+        await installSkills(process.argv.slice(3));
+        return;
+    }
+    console.error(`Unknown command "${command}". Usage: ng-solid-mcp [serve|install-skills]`);
+    process.exitCode = 1;
+}
+const executedPath = realpathOrUndefined(process.argv[1]);
+const modulePath = realpathOrUndefined(fileURLToPath(import.meta.url));
+if (executedPath && modulePath && executedPath === modulePath) {
+    main().catch((error) => {
+        console.error('Fatal error in ng-solid MCP server:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/data.d.ts

@@ -0,0 +1,26 @@
+import type { IconsSnapshot, NsSnapshot } from './types.js';
+/**
+ * Resolves the on-disk location of a data file (`design-system.json` / `icons.json`).
+ *
+ * Fallback chain (first `existsSync` wins):
+ *  1. `process.env.NG_SOLID_MCP_DATA` (directory override, useful for tests/dev)
+ *  2. `../data/<fileName>` relative to this file — matches the published layout,
+ *     `dist/packages/mcp/lib/data.js` -> `dist/packages/mcp/data/<fileName>`
+ *  3. `../../data/<fileName>` relative to this file — matches the dev layout,
+ *     `packages/mcp/src/lib/data.ts` -> `packages/mcp/data/<fileName>`
+ */
+export declare function resolveSnapshotPath(fileName: string): string;
+export declare function loadSnapshot(): NsSnapshot;
+export declare function loadIcons(): IconsSnapshot;
+export declare function textResult(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function jsonResult(value: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/lib/data.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolves the on-disk location of a data file (`design-system.json` / `icons.json`).
+ *
+ * Fallback chain (first `existsSync` wins):
+ *  1. `process.env.NG_SOLID_MCP_DATA` (directory override, useful for tests/dev)
+ *  2. `../data/<fileName>` relative to this file — matches the published layout,
+ *     `dist/packages/mcp/lib/data.js` -> `dist/packages/mcp/data/<fileName>`
+ *  3. `../../data/<fileName>` relative to this file — matches the dev layout,
+ *     `packages/mcp/src/lib/data.ts` -> `packages/mcp/data/<fileName>`
+ */
+export function resolveSnapshotPath(fileName) {
+    const candidates = [];
+    const envDir = process.env.NG_SOLID_MCP_DATA;
+    if (envDir) {
+        candidates.push(join(envDir, fileName));
+    }
+    candidates.push(fileURLToPath(new URL(`../data/${fileName}`, import.meta.url)));
+    candidates.push(fileURLToPath(new URL(`../../data/${fileName}`, import.meta.url)));
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Could not resolve "${fileName}". Tried:\n${candidates.map((path) => `  - ${path}`).join('\n')}`);
+}
+let cachedSnapshot;
+let cachedIcons;
+export function loadSnapshot() {
+    if (!cachedSnapshot) {
+        const path = resolveSnapshotPath('design-system.json');
+        cachedSnapshot = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    return cachedSnapshot;
+}
+export function loadIcons() {
+    if (!cachedIcons) {
+        const path = resolveSnapshotPath('icons.json');
+        cachedIcons = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    return cachedIcons;
+}
+export function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export function jsonResult(value) {
+    return textResult(JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=data.js.map

package/lib/install-skills.d.ts

@@ -0,0 +1 @@
+export declare function installSkills(args: string[]): Promise<void>;

package/lib/install-skills.js

@@ -0,0 +1,159 @@
+// Copies the resolved skill files (`data/skills/<name>/SKILL.md` -- markers
+// already interpolated, see `scripts/lib/extract-guides.mjs`) into a
+// consumer's own skills directory, defaulting to `./.agents/skills/`.
+//
+// `packages/mcp/skills/<name>/SKILL.md` is the *authored* source; this
+// module never reads from it directly. It always distributes the resolved
+// copy so a consumer never sees an unresolved `<!-- ns:... -->` marker.
+import { existsSync } from 'node:fs';
+import { cp, mkdir, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_TARGET_DIR = join('.', '.agents', 'skills');
+function printUsage() {
+    console.error([
+        'Usage: ng-solid-mcp install-skills [--dir <path>] [--list] [--force]',
+        '',
+        '  --dir <path>  Target directory to copy skills into (default: ./.agents/skills)',
+        '  --list        List the skills bundled with this package without copying',
+        '  --force       Overwrite skill directories that already exist at the target'
+    ].join('\n'));
+}
+function parseArgs(args) {
+    const options = {
+        dir: DEFAULT_TARGET_DIR,
+        list: false,
+        force: false
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--dir') {
+            const value = args[i + 1];
+            if (!value) {
+                console.error('install-skills: --dir requires a path argument');
+                return null;
+            }
+            options.dir = value;
+            i += 1;
+            continue;
+        }
+        if (arg === '--list') {
+            options.list = true;
+            continue;
+        }
+        if (arg === '--force') {
+            options.force = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            printUsage();
+            return null;
+        }
+        console.error(`install-skills: unknown argument "${arg}"`);
+        return null;
+    }
+    return options;
+}
+/**
+ * Resolves the on-disk location of the resolved skills directory.
+ *
+ * Fallback chain (first `existsSync` wins), mirroring `resolveSnapshotPath`
+ * in `data.ts`:
+ *  1. `process.env.NG_SOLID_MCP_DATA` (directory override)
+ *  2. `../data/skills` relative to this file -- published layout,
+ *     `dist/packages/mcp/lib/install-skills.js` -> `dist/packages/mcp/data/skills`
+ *  3. `../../data/skills` relative to this file -- dev layout,
+ *     `packages/mcp/src/lib/install-skills.ts` -> `packages/mcp/data/skills`
+ */
+function resolveSkillsSourceDir() {
+    const candidates = [];
+    const envDir = process.env.NG_SOLID_MCP_DATA;
+    if (envDir) {
+        candidates.push(join(envDir, 'skills'));
+    }
+    candidates.push(fileURLToPath(new URL('../data/skills', import.meta.url)));
+    candidates.push(fileURLToPath(new URL('../../data/skills', import.meta.url)));
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Could not resolve the bundled skills directory. Tried:\n${candidates
+        .map((path) => `  - ${path}`)
+        .join('\n')}`);
+}
+async function listSkillNames(skillsSourceDir) {
+    const entries = await readdir(skillsSourceDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+async function readDescription(skillsSourceDir, name) {
+    try {
+        const content = await readFile(join(skillsSourceDir, name, 'SKILL.md'), 'utf8');
+        const match = /^description:\s*(.*)$/m.exec(content);
+        return match ? match[1].trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installSkills(args) {
+    const options = parseArgs(args);
+    if (!options) {
+        process.exitCode = 1;
+        return;
+    }
+    let skillsSourceDir;
+    try {
+        skillsSourceDir = resolveSkillsSourceDir();
+    }
+    catch (error) {
+        console.error(`install-skills: ${error.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const names = await listSkillNames(skillsSourceDir);
+    if (options.list) {
+        console.log(`Available skills (${names.length}):`);
+        for (const name of names) {
+            const description = await readDescription(skillsSourceDir, name);
+            console.log(description ? `  ${name} -- ${description}` : `  ${name}`);
+        }
+        return;
+    }
+    await mkdir(options.dir, { recursive: true });
+    let copied = 0;
+    let skipped = 0;
+    for (const name of names) {
+        const source = join(skillsSourceDir, name);
+        const target = join(options.dir, name);
+        const targetExists = await pathExists(target);
+        if (targetExists && !options.force) {
+            console.warn(`install-skills: "${target}" already exists, skipping (use --force to overwrite)`);
+            skipped += 1;
+            continue;
+        }
+        if (targetExists) {
+            await rm(target, { recursive: true, force: true });
+        }
+        await cp(source, target, { recursive: true });
+        console.log(`install-skills: copied ${name} -> ${target}`);
+        copied += 1;
+    }
+    console.log(`install-skills: ${copied} skill(s) copied, ${skipped} skipped, target "${options.dir}"`);
+    if (copied === 0 && skipped === 0) {
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=install-skills.js.map

package/lib/preset-validator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Angular-free port of `validateNsPreset`
+ * (`packages/design-system/src/lib/theme/utils/theme.utils.ts`).
+ *
+ * The real function throws on the first violation and requires the live `NsThemePreset`
+ * TypeScript types. This port instead walks a plain JS object (typically parsed from JSON an
+ * agent pastes) and collects every violation, reusing the rule ids/messages/patterns already
+ * captured in `snapshot.theme.rules` so the two never drift apart.
+ */
+import type { ThemeRuleDoc } from './types.js';
+export type PresetValidationMode = 'full' | 'overrides';
+export interface PresetViolation {
+    ruleId: string;
+    severity: 'error' | 'warning';
+    path: string;
+    message: string;
+}
+export interface PresetValidationResult {
+    valid: boolean;
+    violations: PresetViolation[];
+}
+export interface PresetLike {
+    name?: unknown;
+    primitive?: unknown;
+    semantic?: {
+        common?: unknown;
+        colorScheme?: {
+            light?: unknown;
+            dark?: unknown;
+        };
+    };
+    components?: unknown;
+}
+/**
+ * Validates a plain-object preset (or a partial override tree) against the ng-solid theme rules.
+ *
+ * `mode: 'full'` expects the complete three-tier shape (`primitive` / `semantic.common` /
+ * `semantic.colorScheme.{light,dark}` / `components`) and validates every rule, including
+ * cross-tier reference resolution. `mode: 'overrides'` treats the input as a
+ * `NsThemePresetOverrides`-shaped partial tree: only present tiers are checked, `preset-name`
+ * is skipped when `name` is absent, and reference checks are skipped for tiers the override
+ * doesn't touch (an override can legitimately reference a base-preset token it doesn't redefine).
+ */
+export declare function validatePreset(preset: PresetLike, rules: ThemeRuleDoc[], mode?: PresetValidationMode): PresetValidationResult;

package/lib/preset-validator.js

@@ -0,0 +1,172 @@
+/**
+ * Angular-free port of `validateNsPreset`
+ * (`packages/design-system/src/lib/theme/utils/theme.utils.ts`).
+ *
+ * The real function throws on the first violation and requires the live `NsThemePreset`
+ * TypeScript types. This port instead walks a plain JS object (typically parsed from JSON an
+ * agent pastes) and collects every violation, reusing the rule ids/messages/patterns already
+ * captured in `snapshot.theme.rules` so the two never drift apart.
+ */
+function parseRegexLiteral(literal) {
+    const match = /^\/(.*)\/([a-z]*)$/.exec(literal);
+    if (!match) {
+        throw new Error(`Not a serialized RegExp literal: ${literal}`);
+    }
+    return new RegExp(match[1], match[2]);
+}
+function ruleFrom(rules, id) {
+    const rule = rules.find((candidate) => candidate.id === id);
+    if (!rule) {
+        throw new Error(`theme rule snapshot is missing rule "${id}"`);
+    }
+    return rule;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Same recursive flatten as the real `flattenTokens` -- map keys are the bare dotted path
+ * within this tier (e.g. `"color.white"`, never `"primitive.color.white"`), because that is
+ * exactly what a `{primitive.color.white}` / `{semantic.x}` reference target must match.
+ * `reportPrefix` (e.g. `"primitive."`) is used only to build human-readable violation paths.
+ */
+function flattenTokens(tree, tokenKeyPattern, tokenKeyRule, reportPrefix, violations) {
+    const tokens = new Map();
+    if (!isRecord(tree))
+        return tokens;
+    const visit = (value, path) => {
+        for (const [key, token] of Object.entries(value)) {
+            if (!tokenKeyPattern.test(key)) {
+                violations.push({
+                    ruleId: tokenKeyRule.id,
+                    severity: tokenKeyRule.severity,
+                    path: `${reportPrefix}${path}${key}`,
+                    message: `${tokenKeyRule.message} -- got "${key}".`
+                });
+                continue;
+            }
+            const nextPath = path ? `${path}${key}` : key;
+            if (isRecord(token)) {
+                visit(token, `${nextPath}.`);
+            }
+            else {
+                tokens.set(nextPath, token);
+            }
+        }
+    };
+    visit(tree, '');
+    return tokens;
+}
+function validateReferences(tokens, pattern, targets, rule, reportPrefix, violations) {
+    for (const [path, value] of tokens) {
+        const reportPath = `${reportPrefix}${path}`;
+        if (typeof value !== 'string') {
+            violations.push({
+                ruleId: rule.id,
+                severity: rule.severity,
+                path: reportPath,
+                message: `${rule.message} -- "${reportPath}" is not a string reference.`
+            });
+            continue;
+        }
+        const target = pattern.exec(value)?.[1];
+        if (!target || !targets.has(target)) {
+            violations.push({
+                ruleId: rule.id,
+                severity: rule.severity,
+                path: reportPath,
+                message: `${rule.message} -- invalid reference at "${reportPath}": ${value}.`
+            });
+        }
+    }
+}
+/**
+ * Validates a plain-object preset (or a partial override tree) against the ng-solid theme rules.
+ *
+ * `mode: 'full'` expects the complete three-tier shape (`primitive` / `semantic.common` /
+ * `semantic.colorScheme.{light,dark}` / `components`) and validates every rule, including
+ * cross-tier reference resolution. `mode: 'overrides'` treats the input as a
+ * `NsThemePresetOverrides`-shaped partial tree: only present tiers are checked, `preset-name`
+ * is skipped when `name` is absent, and reference checks are skipped for tiers the override
+ * doesn't touch (an override can legitimately reference a base-preset token it doesn't redefine).
+ */
+export function validatePreset(preset, rules, mode = 'full') {
+    const violations = [];
+    const tokenKeyRule = ruleFrom(rules, 'token-key');
+    const presetNameRule = ruleFrom(rules, 'preset-name');
+    const unsafeValueRule = ruleFrom(rules, 'unsafe-css-value');
+    const primitiveRefRule = ruleFrom(rules, 'primitive-reference');
+    const semanticRefRule = ruleFrom(rules, 'semantic-reference');
+    const bothSchemesRule = ruleFrom(rules, 'component-token-both-schemes');
+    if (mode === 'full' || preset.name !== undefined) {
+        const namePattern = parseRegexLiteral(presetNameRule.pattern ?? '/^[a-z][a-z0-9-]*$/i');
+        if (typeof preset.name !== 'string' || !namePattern.test(preset.name)) {
+            violations.push({
+                ruleId: presetNameRule.id,
+                severity: presetNameRule.severity,
+                path: 'name',
+                message: `${presetNameRule.message} -- got ${JSON.stringify(preset.name ?? null)}.`
+            });
+        }
+    }
+    const unsafePattern = parseRegexLiteral(unsafeValueRule.pattern ?? '/[;{}]/');
+    const primitives = flattenTokens(preset.primitive, /^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/, tokenKeyRule, 'primitive.', violations);
+    for (const [path, value] of primitives) {
+        if (typeof value === 'string' &&
+            (unsafePattern.test(value) || value.trim().length === 0)) {
+            violations.push({
+                ruleId: unsafeValueRule.id,
+                severity: unsafeValueRule.severity,
+                path,
+                message: `${unsafeValueRule.message} -- got ${JSON.stringify(value)}.`
+            });
+        }
+    }
+    const semanticCommon = flattenTokens(preset.semantic?.common, /^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/, tokenKeyRule, 'semantic.', violations);
+    const semanticLight = flattenTokens(preset.semantic?.colorScheme?.light, /^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/, tokenKeyRule, 'semantic.', violations);
+    const semanticDark = flattenTokens(preset.semantic?.colorScheme?.dark, /^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/, tokenKeyRule, 'semantic.', violations);
+    const primitiveRefPattern = parseRegexLiteral(primitiveRefRule.pattern ?? '/^\\{primitive\\.([a-zA-Z0-9.]+)\\}$/');
+    const havePrimitives = mode === 'full' || primitives.size > 0;
+    if (havePrimitives) {
+        for (const tokens of [semanticCommon, semanticLight, semanticDark]) {
+            if (tokens.size > 0) {
+                validateReferences(tokens, primitiveRefPattern, primitives, primitiveRefRule, 'semantic.', violations);
+            }
+        }
+    }
+    const components = flattenTokens(preset.components, /^(?:[a-z][a-zA-Z0-9]*|[0-9]+)$/, tokenKeyRule, 'components.', violations);
+    const semanticPaths = new Map([
+        ...semanticCommon,
+        ...semanticLight,
+        ...semanticDark
+    ]);
+    const semanticRefPattern = parseRegexLiteral(semanticRefRule.pattern ?? '/^\\{semantic\\.([a-zA-Z0-9.]+)\\}$/');
+    const haveSemantics = mode === 'full' || semanticPaths.size > 0;
+    if (haveSemantics && components.size > 0) {
+        validateReferences(components, semanticRefPattern, semanticPaths, semanticRefRule, 'components.', violations);
+        for (const [path, value] of components) {
+            if (typeof value !== 'string')
+                continue;
+            const semanticPath = semanticRefPattern.exec(value)?.[1];
+            if (!semanticPath)
+                continue;
+            const inCommon = semanticCommon.has(semanticPath);
+            const inBothSchemes = semanticLight.has(semanticPath) && semanticDark.has(semanticPath);
+            if (!inCommon &&
+                !inBothSchemes &&
+                (mode === 'full' || semanticPaths.size > 0)) {
+                violations.push({
+                    ruleId: bothSchemesRule.id,
+                    severity: bothSchemesRule.severity,
+                    path: `components.${path}`,
+                    message: `${bothSchemesRule.message} -- "components.${path}" references "${semanticPath}".`
+                });
+            }
+        }
+    }
+    return {
+        valid: violations.every((violation) => violation.severity !== 'error'),
+        violations
+    };
+}
+//# sourceMappingURL=preset-validator.js.map

package/lib/prompts.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerPrompts(server: McpServer): void;