mcp-probe-kit 3.0.19 → 3.0.22

package/build/utils/__tests__/shadcn-sync.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/__tests__/shadcn-sync.unit.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+import { computeRegistryChecksum, transformRegistryItems, } from '../shadcn-sync.js';
+const sampleRegistry = {
+    name: 'shadcn/ui',
+    items: [
+        {
+            name: 'button',
+            type: 'registry:ui',
+            description: 'Button component',
+            registryDependencies: ['utils'],
+            files: [{ path: 'registry/new-york/ui/button.tsx', target: '' }],
+        },
+        {
+            name: 'dashboard-01',
+            type: 'registry:block',
+            description: 'A dashboard with sidebar, charts and data table.',
+            registryDependencies: ['sidebar', 'chart', 'button'],
+            files: [
+                { path: 'registry/new-york/blocks/dashboard-01/page.tsx', target: 'app/dashboard/page.tsx' },
+            ],
+        },
+        {
+            name: 'index',
+            type: 'registry:style',
+            files: [],
+        },
+    ],
+};
+describe('shadcn-sync', () => {
+    it('transforms registry items into searchable blocks and components', () => {
+        const { blocks, components } = transformRegistryItems(sampleRegistry);
+        expect(blocks).toHaveLength(1);
+        expect(components).toHaveLength(1);
+        expect(blocks[0].name).toBe('dashboard-01');
+        expect(blocks[0].category).toBe('shadcn-blocks');
+        expect(blocks[0].installCommand).toBe('npx shadcn@latest add dashboard-01');
+        expect(components[0].name).toBe('button');
+        expect(components[0].category).toBe('shadcn-components');
+    });
+    it('computes stable checksum for registry signature', () => {
+        const first = computeRegistryChecksum(sampleRegistry);
+        const second = computeRegistryChecksum({
+            ...sampleRegistry,
+            items: [...sampleRegistry.items].reverse(),
+        });
+        expect(first).toBe(second);
+        expect(first).toHaveLength(16);
+    });
+});

package/build/utils/__tests__/theme-pick.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/__tests__/theme-pick.unit.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import { pickThemeForProductType } from '../../lib/shadcn-ui.js';
+import { CURATED_UI_THEMES } from '../themes-sync.js';
+describe('pickThemeForProductType', () => {
+    it('prefers themes whose bestFor matches product type', () => {
+        const picked = pickThemeForProductType(CURATED_UI_THEMES, 'Healthcare App');
+        expect(picked?.name).toBe('green-health');
+    });
+});

package/build/utils/__tests__/themes-sync.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/__tests__/themes-sync.unit.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { CURATED_UI_THEMES, computeThemesChecksum, syncThemesTo } from '../themes-sync.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+describe('themes-sync', () => {
+    it('ships curated shadcn-compatible theme presets', () => {
+        expect(CURATED_UI_THEMES.length).toBeGreaterThanOrEqual(8);
+        const blue = CURATED_UI_THEMES.find((theme) => theme.name === 'blue-saas');
+        expect(blue?.globalsCssSnippet).toContain('--primary:');
+        expect(blue?.category).toBe('ui-themes');
+    });
+    it('writes presets.json when checksum changes', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-themes-'));
+        const result = syncThemesTo(dir, { force: true });
+        expect(result?.count).toBe(CURATED_UI_THEMES.length);
+        expect(fs.existsSync(path.join(dir, 'themes', 'presets.json'))).toBe(true);
+        const again = syncThemesTo(dir, { existingChecksum: computeThemesChecksum() });
+        expect(again).toBeNull();
+    });
+});

package/build/utils/__tests__/ui-metadata.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/__tests__/ui-metadata.unit.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { readUISyncMetadata, writeUISyncMetadata } from '../ui-metadata.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+describe('ui-metadata', () => {
+    it('migrates legacy metadata into sources map', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-meta-'));
+        fs.writeFileSync(path.join(dir, 'metadata.json'), JSON.stringify({
+            version: '2.2.3',
+            syncedAt: '2026-01-01T00:00:00.000Z',
+            source: 'uipro-cli',
+            format: 'json',
+        }));
+        const metadata = readUISyncMetadata(dir);
+        expect(metadata?.sources['uipro-cli']?.version).toBe('2.2.3');
+        expect(metadata?.version).toBe('2.2.3');
+    });
+    it('writes metadata with trailing newline', () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-meta-'));
+        writeUISyncMetadata(dir, {
+            version: '2.2.3',
+            syncedAt: '2026-01-01T00:00:00.000Z',
+            source: 'uipro-cli',
+            format: 'json',
+            sources: {
+                'uipro-cli': { version: '2.2.3', syncedAt: '2026-01-01T00:00:00.000Z' },
+                shadcn: { version: 'abc123', syncedAt: '2026-01-01T00:00:00.000Z', blocks: 10, components: 20 },
+            },
+        });
+        const raw = fs.readFileSync(path.join(dir, 'metadata.json'), 'utf-8');
+        expect(raw.endsWith('\n')).toBe(true);
+        expect(JSON.parse(raw).sources.shadcn.blocks).toBe(10);
+    });
+});

package/build/utils/__tests__/vercel-guidelines-sync.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/__tests__/vercel-guidelines-sync.unit.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { parseVercelGuidelinesMarkdown } from '../vercel-guidelines-sync.js';
+import * as fs from 'fs';
+import * as path from 'path';
+describe('vercel-guidelines-sync', () => {
+    it('parses MUST/SHOULD/NEVER rules from markdown', () => {
+        const sample = `# Title
+
+## Interactions
+
+### Keyboard
+
+- MUST: Visible focus rings
+- NEVER: outline: none without replacement
+
+## Animation
+
+- SHOULD: Prefer CSS animations
+`;
+        const records = parseVercelGuidelinesMarkdown(sample);
+        expect(records).toHaveLength(3);
+        expect(records[0].level).toBe('MUST');
+        expect(records[0].section).toBe('Interactions');
+        expect(records[0].category).toBe('ui-guidelines-vercel');
+        expect(records[1].level).toBe('NEVER');
+    });
+    it('parses bundled fallback markdown file', () => {
+        const fallback = path.join(process.cwd(), 'scripts', 'data', 'vercel-web-interface-guidelines.md');
+        const markdown = fs.readFileSync(fallback, 'utf-8');
+        const records = parseVercelGuidelinesMarkdown(markdown);
+        expect(records.length).toBeGreaterThan(50);
+        expect(records.some((item) => item.rule.includes('prefers-reduced-motion'))).toBe(true);
+    });
+});

package/build/utils/bm25.d.ts

@@ -41,6 +41,7 @@ export declare class BM25 {
      * 批量添加文档
      */
     addDocuments(docs: BM25Document[]): void;
+    private recalculateAvgDocLength;
     /**
      * 计算 IDF (Inverse Document Frequency)
      */
@@ -52,7 +53,7 @@ export declare class BM25 {
     /**
      * 搜索文档
      */
-    search(query: string, limit?: number): BM25SearchResult[];
+    search(query: string, limit?: number, predicate?: (metadata?: Record<string, any>) => boolean): BM25SearchResult[];
     /**
      * 清空索引
      */

package/build/utils/bm25.js

@@ -46,6 +46,7 @@ export class BM25 {
             }
             this.invertedIndex.get(term).set(doc.id, freq);
         }
+        this.recalculateAvgDocLength();
     }
     /**
      * 批量添加文档
@@ -54,7 +55,12 @@ export class BM25 {
         for (const doc of docs) {
             this.addDocument(doc);
         }
-        // 计算平均文档长度
+    }
+    recalculateAvgDocLength() {
+        if (this.documents.length === 0) {
+            this.avgDocLength = 0;
+            return;
+        }
         let totalLength = 0;
         for (const length of this.documentLengths.values()) {
             totalLength += length;
@@ -94,7 +100,7 @@ export class BM25 {
     /**
      * 搜索文档
      */
-    search(query, limit = 10) {
+    search(query, limit = 10, predicate) {
         const queryTerms = this.tokenize(query);
         if (queryTerms.length === 0) {
             return [];
@@ -112,9 +118,15 @@ export class BM25 {
         // 计算得分
         const results = [];
         for (const docId of relevantDocs) {
-            const score = this.calculateScore(docId, queryTerms);
             const doc = this.documents.find(d => d.id === docId);
-            if (doc && score > 0) {
+            if (!doc) {
+                continue;
+            }
+            if (predicate && !predicate(doc.metadata)) {
+                continue;
+            }
+            const score = this.calculateScore(docId, queryTerms);
+            if (score > 0) {
                 results.push({
                     id: docId,
                     score,
@@ -134,6 +146,6 @@ export class BM25 {
         this.documents = [];
         this.invertedIndex.clear();
         this.documentLengths.clear();
-        this.avgDocLength = 0;
+        this.recalculateAvgDocLength();
     }
 }

package/build/utils/shadcn-sync.d.ts

@@ -0,0 +1,55 @@
+/**
+ * shadcn/ui registry 同步（blocks + components 索引）
+ */
+import type { SyncRuntimeOptions } from './ui-sync.js';
+import type { UISourceMetadata } from './ui-metadata.js';
+export declare const SHADCN_REGISTRY_URL = "https://ui.shadcn.com/r/styles/new-york/registry.json";
+export declare const SHADCN_STYLE = "new-york";
+export interface ShadcnRegistryItem {
+    name: string;
+    type?: string;
+    description?: string;
+    dependencies?: string[];
+    registryDependencies?: string[];
+    files?: Array<{
+        path?: string;
+        target?: string;
+        type?: string;
+    }>;
+}
+export interface ShadcnRegistry {
+    name?: string;
+    homepage?: string;
+    items: ShadcnRegistryItem[];
+}
+export interface ShadcnSearchRecord {
+    name: string;
+    title: string;
+    description: string;
+    type: 'block' | 'component' | 'other';
+    stack: string;
+    style: string;
+    dependencies: string[];
+    registryDependencies: string[];
+    fileCount: number;
+    files: string[];
+    installCommand: string;
+    category: string;
+}
+export interface ShadcnSyncResult {
+    metadata: UISourceMetadata;
+    blocks: number;
+    components: number;
+}
+export declare function fetchText(url: string, signal?: AbortSignal): Promise<string>;
+export declare function fetchJson<T>(url: string, signal?: AbortSignal): Promise<T>;
+export declare function computeRegistryChecksum(registry: ShadcnRegistry): string;
+export declare function transformRegistryItems(registry: ShadcnRegistry): {
+    blocks: ShadcnSearchRecord[];
+    components: ShadcnSearchRecord[];
+};
+export declare function fetchShadcnRegistry(signal?: AbortSignal): Promise<ShadcnRegistry>;
+export declare function syncShadcnTo(outputDir: string, options?: SyncRuntimeOptions & {
+    force?: boolean;
+    existingChecksum?: string;
+}): Promise<ShadcnSyncResult | null>;

package/build/utils/shadcn-sync.js

@@ -0,0 +1,146 @@
+/**
+ * shadcn/ui registry 同步（blocks + components 索引）
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+export const SHADCN_REGISTRY_URL = 'https://ui.shadcn.com/r/styles/new-york/registry.json';
+export const SHADCN_STYLE = 'new-york';
+function throwIfAborted(signal, message) {
+    if (!signal?.aborted)
+        return;
+    const err = new Error(message);
+    err.name = 'AbortError';
+    throw err;
+}
+export function fetchText(url, signal) {
+    throwIfAborted(signal, 'Sync cancelled before fetch');
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                const location = res.headers.location;
+                if (location) {
+                    fetchText(location, signal).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`Failed to fetch ${url}: HTTP ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                if (signal?.aborted) {
+                    req.destroy(new Error('Sync cancelled while reading response'));
+                    return;
+                }
+                data += chunk;
+            });
+            res.on('end', () => {
+                throwIfAborted(signal, 'Sync cancelled after fetch');
+                resolve(data);
+            });
+        });
+        const onAbort = () => req.destroy(new Error('Sync cancelled'));
+        signal?.addEventListener('abort', onAbort, { once: true });
+        req.on('error', (error) => {
+            signal?.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+        req.on('close', () => {
+            signal?.removeEventListener('abort', onAbort);
+        });
+    });
+}
+export function fetchJson(url, signal) {
+    return fetchText(url, signal).then((data) => {
+        try {
+            return JSON.parse(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse JSON from ${url}: ${error}`);
+        }
+    });
+}
+export function computeRegistryChecksum(registry) {
+    const signature = (registry.items || [])
+        .map((item) => `${item.name}:${item.type || ''}:${item.description || ''}`)
+        .sort()
+        .join('|');
+    return crypto.createHash('sha256').update(signature).digest('hex').slice(0, 16);
+}
+function normalizeType(raw) {
+    if (raw === 'registry:block')
+        return 'block';
+    if (raw === 'registry:ui')
+        return 'component';
+    return 'other';
+}
+function buildInstallCommand(name, type) {
+    if (type === 'block' || type === 'component') {
+        return `npx shadcn@latest add ${name}`;
+    }
+    return '';
+}
+export function transformRegistryItems(registry) {
+    const blocks = [];
+    const components = [];
+    for (const item of registry.items || []) {
+        const type = normalizeType(item.type);
+        if (type === 'other')
+            continue;
+        const files = (item.files || [])
+            .map((file) => file.target || file.path || '')
+            .filter(Boolean);
+        const record = {
+            name: item.name,
+            title: item.name,
+            description: item.description || `${type} from shadcn/ui (${SHADCN_STYLE})`,
+            type,
+            stack: 'react',
+            style: SHADCN_STYLE,
+            dependencies: item.dependencies || [],
+            registryDependencies: item.registryDependencies || [],
+            fileCount: files.length,
+            files,
+            installCommand: buildInstallCommand(item.name, type),
+            category: type === 'block' ? 'shadcn-blocks' : 'shadcn-components',
+        };
+        if (type === 'block') {
+            blocks.push(record);
+        }
+        else {
+            components.push(record);
+        }
+    }
+    return { blocks, components };
+}
+export async function fetchShadcnRegistry(signal) {
+    return fetchJson(SHADCN_REGISTRY_URL, signal);
+}
+export async function syncShadcnTo(outputDir, options) {
+    throwIfAborted(options?.signal, 'shadcn sync cancelled');
+    const registry = await fetchShadcnRegistry(options?.signal);
+    const checksum = computeRegistryChecksum(registry);
+    if (!options?.force && options?.existingChecksum === checksum) {
+        return null;
+    }
+    const { blocks, components } = transformRegistryItems(registry);
+    const shadcnDir = path.join(outputDir, 'shadcn');
+    if (!fs.existsSync(shadcnDir)) {
+        fs.mkdirSync(shadcnDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(shadcnDir, 'blocks.json'), `${JSON.stringify(blocks, null, 2)}\n`, 'utf-8');
+    fs.writeFileSync(path.join(shadcnDir, 'components.json'), `${JSON.stringify(components, null, 2)}\n`, 'utf-8');
+    const syncedAt = new Date().toISOString();
+    const metadata = {
+        version: checksum,
+        syncedAt,
+        checksum,
+        style: SHADCN_STYLE,
+        blocks: blocks.length,
+        components: components.length,
+    };
+    return { metadata, blocks: blocks.length, components: components.length };
+}

package/build/utils/themes-sync.d.ts

@@ -0,0 +1,32 @@
+/**
+ * shadcn/ui 兼容主题预设（CSS variables，非 tweakcn 全量 fork）
+ * 灵感来源：shadcn themes + tweakcn 风格的现代变量结构
+ */
+import type { UISourceMetadata } from './ui-metadata.js';
+export declare const UI_THEMES_VERSION = "1.0.0";
+export type ThemeCssVars = Record<string, string>;
+export interface UIThemeRecord {
+    name: string;
+    title: string;
+    description: string;
+    style: 'new-york';
+    stack: string;
+    baseColor: string;
+    mood: string;
+    bestFor: string[];
+    cssVarsLight: ThemeCssVars;
+    cssVarsDark: ThemeCssVars;
+    globalsCssSnippet: string;
+    category: string;
+    source: string;
+}
+export interface ThemesSyncResult {
+    metadata: UISourceMetadata;
+    count: number;
+}
+export declare const CURATED_UI_THEMES: UIThemeRecord[];
+export declare function computeThemesChecksum(themes?: UIThemeRecord[]): string;
+export declare function syncThemesTo(outputDir: string, options?: {
+    force?: boolean;
+    existingChecksum?: string;
+}): ThemesSyncResult | null;

package/build/utils/themes-sync.js

@@ -0,0 +1,201 @@
+/**
+ * shadcn/ui 兼容主题预设（CSS variables，非 tweakcn 全量 fork）
+ * 灵感来源：shadcn themes + tweakcn 风格的现代变量结构
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export const UI_THEMES_VERSION = '1.0.0';
+const BASE_LIGHT = {
+    background: '0 0% 100%',
+    foreground: '240 10% 3.9%',
+    card: '0 0% 100%',
+    'card-foreground': '240 10% 3.9%',
+    popover: '0 0% 100%',
+    'popover-foreground': '240 10% 3.9%',
+    secondary: '240 4.8% 95.9%',
+    'secondary-foreground': '240 5.9% 10%',
+    muted: '240 4.8% 95.9%',
+    'muted-foreground': '240 3.8% 46.1%',
+    accent: '240 4.8% 95.9%',
+    'accent-foreground': '240 5.9% 10%',
+    destructive: '0 84.2% 60.2%',
+    'destructive-foreground': '0 0% 98%',
+    border: '240 5.9% 90%',
+    input: '240 5.9% 90%',
+    ring: '240 5.9% 10%',
+    radius: '0.5rem',
+};
+const BASE_DARK = {
+    background: '240 10% 3.9%',
+    foreground: '0 0% 98%',
+    card: '240 10% 3.9%',
+    'card-foreground': '0 0% 98%',
+    popover: '240 10% 3.9%',
+    'popover-foreground': '0 0% 98%',
+    secondary: '240 3.7% 15.9%',
+    'secondary-foreground': '0 0% 98%',
+    muted: '240 3.7% 15.9%',
+    'muted-foreground': '240 5% 64.9%',
+    accent: '240 3.7% 15.9%',
+    'accent-foreground': '0 0% 98%',
+    destructive: '0 62.8% 30.6%',
+    'destructive-foreground': '0 0% 98%',
+    border: '240 3.7% 15.9%',
+    input: '240 3.7% 15.9%',
+    ring: '240 4.9% 83.9%',
+    radius: '0.5rem',
+};
+function withPrimary(light, dark, primaryLight, primaryDark) {
+    return {
+        light: {
+            ...light,
+            primary: primaryLight,
+            'primary-foreground': '0 0% 98%',
+            ring: primaryLight,
+        },
+        dark: {
+            ...dark,
+            primary: primaryDark,
+            'primary-foreground': '240 5.9% 10%',
+            ring: primaryDark,
+        },
+    };
+}
+function renderGlobalsCss(name, light, dark) {
+    const toBlock = (vars) => Object.entries(vars)
+        .map(([key, value]) => `    --${key}: ${value};`)
+        .join('\n');
+    return `@layer base {
+  /* Theme: ${name} — paste into globals.css */
+  :root {
+${toBlock(light)}
+  }
+  .dark {
+${toBlock(dark)}
+  }
+}`;
+}
+function buildTheme(input) {
+    const { light, dark } = withPrimary(BASE_LIGHT, BASE_DARK, input.primaryLight, input.primaryDark);
+    return {
+        name: input.name,
+        title: input.title,
+        description: input.description,
+        style: 'new-york',
+        stack: 'react',
+        baseColor: input.baseColor,
+        mood: input.mood,
+        bestFor: input.bestFor,
+        cssVarsLight: light,
+        cssVarsDark: dark,
+        globalsCssSnippet: renderGlobalsCss(input.name, light, dark),
+        category: 'ui-themes',
+        source: 'mcp-probe-kit-curated-shadcn',
+    };
+}
+export const CURATED_UI_THEMES = [
+    buildTheme({
+        name: 'zinc-neutral',
+        title: 'Zinc Neutral',
+        description: '默认中性 SaaS 风格，低饱和、专业克制',
+        baseColor: 'zinc',
+        mood: 'neutral professional',
+        bestFor: ['SaaS', 'B2B', 'Admin'],
+        primaryLight: '240 5.9% 10%',
+        primaryDark: '0 0% 98%',
+    }),
+    buildTheme({
+        name: 'slate-dashboard',
+        title: 'Slate Dashboard',
+        description: '偏冷灰的数据看板与分析产品',
+        baseColor: 'slate',
+        mood: 'cool analytical',
+        bestFor: ['Analytics Dashboard', 'Fintech'],
+        primaryLight: '215.4 16.3% 36.9%',
+        primaryDark: '210 40% 98%',
+    }),
+    buildTheme({
+        name: 'blue-saas',
+        title: 'Blue SaaS',
+        description: '常见 B2B 蓝色主色，清晰可信',
+        baseColor: 'blue',
+        mood: 'trustworthy modern',
+        bestFor: ['SaaS', 'B2B Service'],
+        primaryLight: '221.2 83.2% 53.3%',
+        primaryDark: '217.2 91.2% 59.8%',
+    }),
+    buildTheme({
+        name: 'violet-creative',
+        title: 'Violet Creative',
+        description: '偏创意工具/设计产品的紫色主色',
+        baseColor: 'violet',
+        mood: 'creative premium',
+        bestFor: ['Creative Agency', 'Portfolio'],
+        primaryLight: '262.1 83.3% 57.8%',
+        primaryDark: '263.4 70% 50.4%',
+    }),
+    buildTheme({
+        name: 'rose-beauty',
+        title: 'Rose Beauty',
+        description: '美妆/生活方式产品的柔和玫瑰色',
+        baseColor: 'rose',
+        mood: 'soft elegant',
+        bestFor: ['Beauty', 'E-commerce'],
+        primaryLight: '346.8 77.2% 49.8%',
+        primaryDark: '346.8 77.2% 49.8%',
+    }),
+    buildTheme({
+        name: 'green-health',
+        title: 'Green Health',
+        description: '医疗/健康类产品的绿色主色',
+        baseColor: 'green',
+        mood: 'calm trustworthy',
+        bestFor: ['Healthcare App', 'Educational App'],
+        primaryLight: '142.1 76.2% 36.3%',
+        primaryDark: '142.1 70.6% 45.3%',
+    }),
+    buildTheme({
+        name: 'orange-energy',
+        title: 'Orange Energy',
+        description: '活动/增长类产品的橙色主色',
+        baseColor: 'orange',
+        mood: 'energetic friendly',
+        bestFor: ['Social Media App', 'Government/Public Service'],
+        primaryLight: '24.6 95% 53.1%',
+        primaryDark: '20.5 90.2% 48.2%',
+    }),
+    buildTheme({
+        name: 'stone-editorial',
+        title: 'Stone Editorial',
+        description: '内容/媒体站点常用的暖灰 editorial 感',
+        baseColor: 'stone',
+        mood: 'editorial warm',
+        bestFor: ['Portfolio/Personal', 'Educational App'],
+        primaryLight: '25 5.3% 24.7%',
+        primaryDark: '60 9.1% 97.8%',
+    }),
+];
+export function computeThemesChecksum(themes = CURATED_UI_THEMES) {
+    const signature = themes.map((theme) => `${theme.name}:${UI_THEMES_VERSION}`).join('|');
+    return crypto.createHash('sha256').update(signature).digest('hex').slice(0, 16);
+}
+export function syncThemesTo(outputDir, options) {
+    const checksum = computeThemesChecksum();
+    if (!options?.force && options?.existingChecksum === checksum) {
+        return null;
+    }
+    const themesDir = path.join(outputDir, 'themes');
+    if (!fs.existsSync(themesDir)) {
+        fs.mkdirSync(themesDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(themesDir, 'presets.json'), `${JSON.stringify(CURATED_UI_THEMES, null, 2)}\n`, 'utf-8');
+    return {
+        metadata: {
+            version: UI_THEMES_VERSION,
+            syncedAt: new Date().toISOString(),
+            checksum,
+        },
+        count: CURATED_UI_THEMES.length,
+    };
+}