@schemyx/mcp 0.1.0 → 0.1.2

package/dist/client/local-theme-source.js

@@ -0,0 +1,737 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalThemeSource = void 0;
+exports.createLocalThemeSourceIfAvailable = createLocalThemeSourceIfAvailable;
+const node_fs_1 = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const node_url_1 = require("node:url");
+const style_recipes_1 = require("../theme/style-recipes");
+const localConfigId = 'local-theme';
+const localProjectId = 'local-project';
+const themeForgeResourceIds = {
+    bundle: 'theme-forge.bundle',
+    source: 'theme-forge.source',
+    files: 'theme-forge.files',
+    implementationGuide: 'theme-forge.implementation-guide',
+};
+const themeForgeToolNames = {
+    getBundle: 'theme-forge.get-bundle',
+    listFiles: 'theme-forge.list-files',
+    getFile: 'theme-forge.get-file',
+    listStyleRecipes: 'theme-forge.list-style-recipes',
+    getStyleRecipe: 'theme-forge.get-style-recipe',
+    getImplementationGuide: 'theme-forge.get-implementation-guide',
+};
+const defaultFileOrder = [
+    'agent-style-index.json',
+    'agent-style-contract.json',
+    'themeforge.json',
+    'theme.css',
+    'tailwind-theme.css',
+    'shadcn-globals.css',
+    'mui-theme.ts',
+    'chakra-system.ts',
+    'mantine-theme.ts',
+    'styled-theme.ts',
+    'theme.scss',
+    'tokens.json',
+    'react-native-theme.ts',
+    'tailwind.config.tokens.ts',
+    'implementation-guide.md',
+    'schemyx-theme-bundle.manifest.json',
+];
+const discoverableFileExtensions = new Set([
+    '.css',
+    '.scss',
+    '.json',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.md',
+    '.mdx',
+]);
+const ignoredDiscoveredFileNames = new Set([
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'bun.lockb',
+    'tsconfig.json',
+    'tsconfig.tsbuildinfo',
+    'next-env.d.ts',
+]);
+const maxDiscoveredFileBytes = 512_000;
+const fileDescriptors = new Map([
+    [
+        'agent-style-index.json',
+        {
+            label: 'Agent style index',
+            description: 'Compact list of Schemyx style recipe keys for targeted MCP lookup.',
+        },
+    ],
+    [
+        'agent-style-contract.json',
+        {
+            label: 'Agent style contract',
+            description: 'Compact machine-readable Schemyx style recipes for AI UI generation.',
+        },
+    ],
+    [
+        'themeforge.json',
+        {
+            label: 'Theme contract',
+            description: 'The source-of-truth Theme Forge token contract.',
+        },
+    ],
+    [
+        'theme.css',
+        {
+            label: 'Theme CSS',
+            description: 'Framework-agnostic CSS variables and theme primitives.',
+        },
+    ],
+    [
+        'tailwind-theme.css',
+        {
+            label: 'Tailwind Theme',
+            description: 'Tailwind v4 CSS theme variables mapped to the generated tokens.',
+        },
+    ],
+    [
+        'shadcn-globals.css',
+        {
+            label: 'shadcn globals',
+            description: 'Tailwind v4 and shadcn/ui globals bridge.',
+        },
+    ],
+    [
+        'mui-theme.ts',
+        {
+            label: 'MUI Theme',
+            description: 'Material UI theme object synchronized to the generated spec.',
+        },
+    ],
+    [
+        'chakra-system.ts',
+        {
+            label: 'Chakra System',
+            description: 'Chakra UI system config synchronized to the theme tokens.',
+        },
+    ],
+    [
+        'mantine-theme.ts',
+        {
+            label: 'Mantine Theme',
+            description: 'Mantine createTheme adapter for the generated visual system.',
+        },
+    ],
+    [
+        'styled-theme.ts',
+        {
+            label: 'Styled Theme',
+            description: 'Typed theme object for styled-components and Emotion providers.',
+        },
+    ],
+    [
+        'theme.scss',
+        {
+            label: 'SCSS Tokens',
+            description: 'SCSS variables and mixins for Angular component styles.',
+        },
+    ],
+    [
+        'tokens.json',
+        {
+            label: 'Design Tokens',
+            description: 'Portable token JSON for Style Dictionary or custom pipelines.',
+        },
+    ],
+    [
+        'react-native-theme.ts',
+        {
+            label: 'React Native Theme',
+            description: 'Native token object for React Native component systems.',
+        },
+    ],
+    [
+        'tailwind.config.tokens.ts',
+        {
+            label: 'Tailwind tokens',
+            description: 'Tailwind v3 token adapter for projects using tailwind.config.ts.',
+        },
+    ],
+    [
+        'implementation-guide.md',
+        {
+            label: 'Implementation guide',
+            description: 'AI-facing instructions for applying the theme without drift.',
+        },
+    ],
+    [
+        'schemyx-theme-bundle.manifest.json',
+        {
+            label: 'Bundle manifest',
+            description: 'Machine-readable file list for local tooling.',
+        },
+    ],
+]);
+async function createLocalThemeSourceIfAvailable(config) {
+    if (config.sourceMode === 'remote') {
+        return null;
+    }
+    const themeDir = await findLocalThemeDir(config);
+    if (!themeDir) {
+        if (config.sourceMode === 'local') {
+            throw new Error('SCHEMYX_MCP_SOURCE=local was set, but no local themeforge.json file was found.');
+        }
+        return null;
+    }
+    return new LocalThemeSource(themeDir);
+}
+class LocalThemeSource {
+    themeDir;
+    bundleCache = null;
+    configCache = null;
+    constructor(themeDir) {
+        this.themeDir = themeDir;
+    }
+    async listConfigs() {
+        return [await this.getLocalConfig()];
+    }
+    async discoverConfigs() {
+        const config = await this.getLocalConfig();
+        return [
+            {
+                config,
+                manifest: await this.getManifest(config.id),
+            },
+        ];
+    }
+    async getManifest(configId) {
+        this.assertLocalConfig(configId);
+        const bundle = await this.getBundle();
+        const resources = [
+            createResource(themeForgeResourceIds.bundle, 'Theme Bundle', 'The complete local theme bundle.'),
+            createResource(themeForgeResourceIds.source, bundle.sourceOfTruth, 'The Theme Forge source-of-truth theme JSON.'),
+            createResource(themeForgeResourceIds.files, 'Theme Files Manifest', 'Generated file metadata for the selected target stack.'),
+            ...bundle.files.map((file) => createFileResource(this.themeDir, file)),
+            createResource(themeForgeResourceIds.implementationGuide, 'Implementation Guide', 'AI-facing instructions for applying this saved theme.', 'text/markdown', 'text'),
+        ];
+        return {
+            configId: localConfigId,
+            providers: [{ id: 'theme-forge.local', name: 'Local Theme Forge Files' }],
+            resources,
+            tools: createTools(bundle),
+            prompts: [
+                {
+                    id: 'theme-forge.apply-theme',
+                    name: 'Apply Schemyx Theme',
+                    description: 'Use the local Schemyx theme contract before building or restyling UI.',
+                    arguments: [
+                        {
+                            name: 'task',
+                            description: 'The UI or product workflow to build.',
+                            required: true,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async getLatestConfig(configId) {
+        this.assertLocalConfig(configId);
+        return this.getLocalConfig();
+    }
+    async readResource(configId, resourceId) {
+        this.assertLocalConfig(configId);
+        const bundle = await this.getBundle();
+        if (resourceId === themeForgeResourceIds.bundle) {
+            return {
+                resource: createResource(themeForgeResourceIds.bundle, 'Theme Bundle', 'The complete local theme bundle.'),
+                content: bundle,
+            };
+        }
+        if (resourceId === themeForgeResourceIds.source) {
+            return {
+                resource: createResource(themeForgeResourceIds.source, bundle.sourceOfTruth, 'The Theme Forge source-of-truth theme JSON.'),
+                content: bundle.themeforge,
+            };
+        }
+        if (resourceId === themeForgeResourceIds.files) {
+            return {
+                resource: createResource(themeForgeResourceIds.files, 'Theme Files Manifest', 'Generated file metadata for the selected target stack.'),
+                content: createFilesManifest(bundle),
+            };
+        }
+        if (resourceId === themeForgeResourceIds.implementationGuide) {
+            return {
+                resource: createResource(themeForgeResourceIds.implementationGuide, 'Implementation Guide', 'AI-facing instructions for applying this saved theme.', 'text/markdown', 'text'),
+                content: getImplementationGuide(bundle),
+            };
+        }
+        const file = findFileByResourceId(bundle, resourceId);
+        if (!file) {
+            throw new Error(`Local Schemyx resource not found: ${resourceId}`);
+        }
+        return {
+            resource: createFileResource(this.themeDir, file),
+            content: file.content,
+        };
+    }
+    async executeTool(configId, toolName, args) {
+        this.assertLocalConfig(configId);
+        const bundle = await this.getBundle();
+        if (toolName === themeForgeToolNames.getBundle) {
+            return {
+                tool: createTool(themeForgeToolNames.getBundle, 'Get Theme Bundle', 'Return the full local Theme Forge bundle.'),
+                contentType: 'json',
+                content: bundle,
+            };
+        }
+        if (toolName === themeForgeToolNames.listFiles) {
+            return {
+                tool: createTool(themeForgeToolNames.listFiles, 'List Theme Files', 'List local theme files.'),
+                contentType: 'json',
+                content: createFilesManifest(bundle),
+            };
+        }
+        if (toolName === themeForgeToolNames.getImplementationGuide) {
+            return {
+                tool: createTool(themeForgeToolNames.getImplementationGuide, 'Get Implementation Guide', 'Return AI-facing instructions for applying this local theme.'),
+                contentType: 'text',
+                content: getImplementationGuide(bundle),
+            };
+        }
+        if (toolName === themeForgeToolNames.listStyleRecipes) {
+            return {
+                tool: createListStyleRecipesTool(),
+                contentType: 'json',
+                content: (0, style_recipes_1.listStyleRecipes)(bundle, args),
+            };
+        }
+        if (toolName === themeForgeToolNames.getStyleRecipe) {
+            const recipe = (0, style_recipes_1.getStyleRecipe)(bundle, args);
+            if (!recipe) {
+                throw new Error('Local Theme Forge style recipe not found.');
+            }
+            return {
+                tool: createGetStyleRecipeTool(bundle),
+                contentType: 'json',
+                content: recipe,
+            };
+        }
+        if (toolName !== themeForgeToolNames.getFile) {
+            throw new Error(`Local Schemyx tool not found: ${toolName}`);
+        }
+        const file = findFile(bundle, args);
+        if (!file) {
+            throw new Error('Local Theme Forge file not found.');
+        }
+        return {
+            tool: createGetFileTool(bundle),
+            contentType: 'text',
+            content: file.content,
+            metadata: {
+                id: file.id,
+                fileName: file.fileName,
+                label: file.label,
+                description: file.description,
+            },
+        };
+    }
+    async resolveConfigId(configId) {
+        if (!configId || configId === localConfigId) {
+            return localConfigId;
+        }
+        throw new Error(`Local Schemyx theme files are active, but configId "${configId}" is not available.`);
+    }
+    async getBundle() {
+        this.bundleCache ??= loadLocalThemeBundle(this.themeDir);
+        return this.bundleCache;
+    }
+    async getLocalConfig() {
+        this.configCache ??= this.createLocalConfig();
+        return this.configCache;
+    }
+    async createLocalConfig() {
+        const bundle = await this.getBundle();
+        return {
+            id: localConfigId,
+            projectId: localProjectId,
+            name: bundle.themeName,
+            key: 'local-theme',
+            type: 'THEME',
+            status: 'ACTIVE',
+            source: 'LOCAL_FILES',
+            description: `Local Theme Forge files from ${this.themeDir}`,
+            targetPath: path.join(this.themeDir, bundle.sourceOfTruth),
+            schema: {
+                name: 'Local Theme Forge theme config',
+                version: 'schemyx.theme-bundle.v1',
+            },
+            validation: {
+                status: 'local',
+                checks: ['themeforge-json-present', 'local-files-readable'],
+            },
+            metadata: {
+                source: 'local-files',
+                themeDir: this.themeDir,
+            },
+            createdAt: bundle.generatedAt,
+            updatedAt: bundle.generatedAt,
+            latestVersion: {
+                id: 'local-theme-version',
+                version: 1,
+                content: bundle,
+                createdAt: bundle.generatedAt,
+            },
+        };
+    }
+    assertLocalConfig(configId) {
+        if (configId !== localConfigId) {
+            throw new Error(`Local Schemyx config not found: ${configId}`);
+        }
+    }
+}
+exports.LocalThemeSource = LocalThemeSource;
+async function findLocalThemeDir(config) {
+    if (config.themeDir) {
+        const explicitDir = path.resolve(config.cwd, config.themeDir);
+        if (!(await hasThemeForgeJson(explicitDir))) {
+            throw new Error(`SCHEMYX_THEME_DIR does not contain themeforge.json: ${explicitDir}`);
+        }
+        return explicitDir;
+    }
+    for (const root of collectSearchRoots(config.cwd)) {
+        for (const candidate of [
+            path.join(root, 'schemyx-ui-theme'),
+            path.join(root, '.schemyx', 'theme'),
+            root,
+        ]) {
+            if (await hasThemeForgeJson(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function collectSearchRoots(cwd) {
+    const roots = [];
+    const seen = new Set();
+    let current = path.resolve(cwd);
+    const home = os.homedir();
+    for (let index = 0; index < 12; index += 1) {
+        if (!seen.has(current)) {
+            seen.add(current);
+            roots.push(current);
+        }
+        if (current === home || current === path.dirname(current)) {
+            break;
+        }
+        current = path.dirname(current);
+    }
+    return roots;
+}
+async function hasThemeForgeJson(candidateDir) {
+    try {
+        const stat = await node_fs_1.promises.stat(path.join(candidateDir, 'themeforge.json'));
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function loadLocalThemeBundle(themeDir) {
+    const themeforgePath = path.join(themeDir, 'themeforge.json');
+    const [themeforgeText, themeforgeStat] = await Promise.all([
+        node_fs_1.promises.readFile(themeforgePath, 'utf8'),
+        node_fs_1.promises.stat(themeforgePath),
+    ]);
+    const themeforge = JSON.parse(themeforgeText);
+    const manifest = await readJsonIfExists(path.join(themeDir, 'schemyx-theme-bundle.manifest.json'));
+    const files = await loadThemeFiles(themeDir, themeforgeText, manifest);
+    return {
+        schemaVersion: 'schemyx.theme-bundle.v1',
+        generatedAt: themeforgeStat.mtime.toISOString(),
+        themeName: stringValue(themeforge.themeName) ?? stringValue(manifest?.themeName) ?? 'Local Theme',
+        targetStack: stringValue(themeforge.stack) ?? stringValue(manifest?.targetStack) ?? 'local',
+        targetStackLabel: stringValue(themeforge.targetStackLabel) ?? 'Local Theme Files',
+        sourceOfTruth: 'themeforge.json',
+        themeforge,
+        files,
+        ...(themeforge.intelligence ? { intelligence: themeforge.intelligence } : {}),
+    };
+}
+async function loadThemeFiles(themeDir, themeforgeText, manifest) {
+    const fileNames = new Set(defaultFileOrder);
+    for (const fileName of await discoverLocalThemeFiles(themeDir)) {
+        fileNames.add(fileName);
+    }
+    for (const file of manifest?.files ?? []) {
+        if (typeof file.path === 'string' && !path.isAbsolute(file.path) && !file.path.includes('..')) {
+            fileNames.add(file.path);
+        }
+    }
+    const files = [];
+    for (const fileName of fileNames) {
+        const fullPath = path.join(themeDir, fileName);
+        const content = fileName === 'themeforge.json' ? themeforgeText : await readTextIfExists(fullPath);
+        if (content === null) {
+            continue;
+        }
+        const manifestEntry = manifest?.files?.find((file) => file.path === fileName);
+        const descriptor = fileDescriptors.get(fileName);
+        files.push({
+            id: toFileId(fileName),
+            fileName,
+            label: descriptor?.label ?? titleFromFileName(fileName),
+            description: stringValue(manifestEntry?.description) ??
+                descriptor?.description ??
+                `Local theme file: ${fileName}.`,
+            content,
+        });
+    }
+    return files;
+}
+async function discoverLocalThemeFiles(themeDir) {
+    const entries = await node_fs_1.promises.readdir(themeDir, { withFileTypes: true });
+    const fileNames = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !isDiscoverableThemeFile(entry.name)) {
+            continue;
+        }
+        const fullPath = path.join(themeDir, entry.name);
+        const stat = await node_fs_1.promises.stat(fullPath);
+        if (stat.size > maxDiscoveredFileBytes) {
+            continue;
+        }
+        fileNames.push(entry.name);
+    }
+    return fileNames.sort((a, b) => a.localeCompare(b));
+}
+function isDiscoverableThemeFile(fileName) {
+    if (fileName.startsWith('.') || ignoredDiscoveredFileNames.has(fileName)) {
+        return false;
+    }
+    return discoverableFileExtensions.has(path.extname(fileName));
+}
+async function readTextIfExists(filePath) {
+    try {
+        const stat = await node_fs_1.promises.stat(filePath);
+        if (!stat.isFile()) {
+            return null;
+        }
+        return await node_fs_1.promises.readFile(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function readJsonIfExists(filePath) {
+    const text = await readTextIfExists(filePath);
+    if (!text) {
+        return null;
+    }
+    return JSON.parse(text);
+}
+function createFilesManifest(bundle) {
+    return {
+        themeName: bundle.themeName,
+        targetStack: bundle.targetStack,
+        targetStackLabel: bundle.targetStackLabel,
+        sourceOfTruth: bundle.sourceOfTruth,
+        files: bundle.files.map((file) => ({
+            id: file.id,
+            fileName: file.fileName,
+            label: file.label,
+            description: file.description,
+            resourceId: createFileResourceId(file),
+        })),
+    };
+}
+function getImplementationGuide(bundle) {
+    const guide = bundle.files.find((file) => file.fileName === 'implementation-guide.md');
+    const agentContract = bundle.files.find((file) => file.fileName === 'agent-style-contract.json');
+    if (guide) {
+        return guide.content;
+    }
+    return [
+        `# Apply ${bundle.themeName}`,
+        '',
+        `Use ${agentContract?.fileName ?? bundle.sourceOfTruth} first before writing UI code.`,
+        'If agent-style-contract.json is present, treat it as the compact element recipe source and use markdown guides only as fallback detail.',
+        `Target stack: ${bundle.targetStackLabel}.`,
+        '',
+        'Read the generated files from this MCP server instead of inventing colors, radius, spacing, shadows, or typography.',
+    ].join('\n');
+}
+function findFile(bundle, args) {
+    const fileName = typeof args.fileName === 'string' ? args.fileName : null;
+    const fileId = typeof args.fileId === 'string' ? args.fileId : null;
+    return bundle.files.find((file) => file.fileName === fileName || file.id === fileId) ?? null;
+}
+function findFileByResourceId(bundle, resourceId) {
+    return bundle.files.find((file) => createFileResourceId(file) === resourceId) ?? null;
+}
+function createFileResourceId(file) {
+    return `theme-forge.file.${file.id}`;
+}
+function createResource(id, name, description, mimeType = 'application/json', kind = 'json') {
+    return {
+        id,
+        uri: `schemyx-local://configs/${localConfigId}/theme-forge/${id}`,
+        name,
+        description,
+        mimeType,
+        kind,
+    };
+}
+function createFileResource(themeDir, file) {
+    return {
+        id: createFileResourceId(file),
+        uri: (0, node_url_1.pathToFileURL)(path.join(themeDir, file.fileName)).toString(),
+        name: file.fileName,
+        description: file.description,
+        mimeType: getMimeType(file.fileName),
+        kind: 'text',
+        metadata: {
+            artifactId: file.id,
+            label: file.label,
+            source: 'local-files',
+        },
+    };
+}
+function createTools(bundle) {
+    return [
+        createTool(themeForgeToolNames.getBundle, 'Get Theme Bundle', 'Return the full local Theme Forge bundle.'),
+        createTool(themeForgeToolNames.listFiles, 'List Theme Files', 'List local theme files.'),
+        createGetFileTool(bundle),
+        ...((0, style_recipes_1.hasStyleRecipes)(bundle)
+            ? [createListStyleRecipesTool(), createGetStyleRecipeTool(bundle)]
+            : []),
+        createTool(themeForgeToolNames.getImplementationGuide, 'Get Implementation Guide', 'Return AI-facing instructions for applying this local theme.'),
+    ];
+}
+function createTool(name, title, description) {
+    return {
+        name,
+        title,
+        description,
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+        readOnly: true,
+    };
+}
+function createListStyleRecipesTool() {
+    return {
+        name: themeForgeToolNames.listStyleRecipes,
+        title: 'List Style Recipes',
+        description: 'List compact Schemyx style recipe keys for targeted agent lookup.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional search across recipe key, group, summary, and tags.',
+                },
+                group: {
+                    type: 'string',
+                    description: 'Optional exact recipe group filter, such as ui, nav, studio, or tokens.',
+                },
+            },
+            additionalProperties: false,
+        },
+        readOnly: true,
+    };
+}
+function createGetStyleRecipeTool(bundle) {
+    return {
+        name: themeForgeToolNames.getStyleRecipe,
+        title: 'Get Style Recipe',
+        description: 'Return one compact Schemyx style recipe by key, optionally with dependencies.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: {
+                    type: 'string',
+                    enum: (0, style_recipes_1.getStyleRecipeKeys)(bundle),
+                },
+                includeDeps: {
+                    type: 'boolean',
+                    description: 'Include direct token/component dependencies. Defaults to true.',
+                },
+            },
+            required: ['key'],
+            additionalProperties: false,
+        },
+        readOnly: true,
+    };
+}
+function createGetFileTool(bundle) {
+    return {
+        name: themeForgeToolNames.getFile,
+        title: 'Get Theme File',
+        description: 'Return one local Theme Forge artifact by file name or artifact id.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fileName: {
+                    type: 'string',
+                    enum: bundle.files.map((file) => file.fileName),
+                },
+                fileId: {
+                    type: 'string',
+                    enum: bundle.files.map((file) => file.id),
+                },
+            },
+            additionalProperties: false,
+        },
+        readOnly: true,
+    };
+}
+function getMimeType(fileName) {
+    if (fileName.endsWith('.json')) {
+        return 'application/json';
+    }
+    if (fileName.endsWith('.css')) {
+        return 'text/css';
+    }
+    if (fileName.endsWith('.ts') || fileName.endsWith('.tsx')) {
+        return 'text/typescript';
+    }
+    if (fileName.endsWith('.js') ||
+        fileName.endsWith('.jsx') ||
+        fileName.endsWith('.mjs') ||
+        fileName.endsWith('.cjs')) {
+        return 'text/javascript';
+    }
+    if (fileName.endsWith('.md') || fileName.endsWith('.mdx')) {
+        return 'text/markdown';
+    }
+    return 'text/plain';
+}
+function toFileId(fileName) {
+    return fileName
+        .replace(/[^a-z0-9]+/gi, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+function titleFromFileName(fileName) {
+    return fileName
+        .replace(/\.[^.]+$/, '')
+        .split(/[-_.]+/)
+        .filter(Boolean)
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+//# sourceMappingURL=local-theme-source.js.map