@preply/ds-ai-mcp 11.1.0

package/dist/create-server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;
+//# sourceMappingURL=create-server.d.ts.map

package/dist/create-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-server.d.ts","sourceRoot":"","sources":["../src/create-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsCpE,wBAAgB,YAAY,cAW3B"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-server';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { t as createServer } from "./create-server-LzOTK9vc.js";
+export { createServer };

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "@preply/ds-ai-mcp",
+    "description": "MCP server for the Preply Design System",
+    "version": "11.1.0",
+    "publishConfig": {
+        "access": "public"
+    },
+    "type": "module",
+    "bin": "./dist/bin.js",
+    "exports": {
+        ".": "./dist/index.js"
+    },
+    "scripts": {
+        "clean": "rm -rf dist",
+        "check:types": "run --top-level tsc --noEmit",
+        "lint": "run --top-level eslint .",
+        "build": "vite build",
+        "dev": "vite build --watch",
+        "dev:inspector": "mcp-inspector tsx src/bin.ts start"
+    },
+    "devDependencies": {
+        "@modelcontextprotocol/inspector": "^0.17.2",
+        "@types/node": "^24.12.0",
+        "tsx": "^4.20.6",
+        "vite": "^8.0.0",
+        "vite-plugin-dts": "^4.5.4"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.20.2",
+        "@preply/ds-ai-core": "11.1.0",
+        "commander": "^14.0.0"
+    },
+    "gitHead": "a5330f56c6c03a557b29efefcabacb41d67f4b63"
+}

package/src/__tests__/create-server.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from 'vitest';
+import { tools } from '@preply/ds-ai-core';
+
+vi.mock(import('@preply/ds-ai-core'), async importOriginal => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        identify: vi.fn(),
+        trackToolCall: vi.fn(),
+    };
+});
+
+import { createServer } from '../create-server';
+
+function getRegisteredTools(server: ReturnType<typeof createServer>) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (server as any)._registeredTools as Record<
+        string,
+        { description?: string; enabled: boolean; annotations?: Record<string, unknown> }
+    >;
+}
+
+describe('createServer', () => {
+    it('creates a server instance', () => {
+        const server = createServer();
+        expect(server).toBeDefined();
+    });
+
+    it('registers all tools from ai-core', () => {
+        const server = createServer();
+        const registered = getRegisteredTools(server);
+        const expectedToolNames = Object.values(tools).map(t => t.name);
+
+        expect(Object.keys(registered)).toEqual(expect.arrayContaining(expectedToolNames));
+        expect(Object.keys(registered)).toHaveLength(expectedToolNames.length);
+    });
+
+    it('sets correct annotations on all registered tools', () => {
+        const server = createServer();
+        const registered = getRegisteredTools(server);
+
+        for (const tool of Object.values(registered)) {
+            expect(tool.annotations).toEqual({
+                readOnlyHint: true,
+                openWorldHint: false,
+                idempotentHint: true,
+                destructiveHint: false,
+            });
+        }
+    });
+
+    it('registers tools as enabled', () => {
+        const server = createServer();
+        const registered = getRegisteredTools(server);
+
+        for (const tool of Object.values(registered)) {
+            expect(tool.enabled).toBe(true);
+        }
+    });
+});

package/src/bin.ts

@@ -0,0 +1,23 @@
+import { program } from 'commander';
+import pkg from '../package.json' with { type: 'json' };
+import { createServer } from './create-server';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+// prettier-ignore
+program
+    .name(Object.keys(pkg.bin)[0])
+    .description(pkg.description)
+    .version(pkg.version, '-v, --version', 'Output the version number')
+    .usage('<command>');
+
+// prettier-ignore
+program
+    .command('start')
+    .description('Start the MCP server')
+    .action(async () => {
+        const transport = new StdioServerTransport();
+        const server = createServer();
+        await server.connect(transport);
+    });
+
+program.parse();

package/src/create-server.ts

@@ -0,0 +1,50 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import pkg from '../package.json' with { type: 'json' };
+import { tools, type Tool, trackToolCall, identify } from '@preply/ds-ai-core';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function registerTool<T extends Tool<any, any>>(server: McpServer, tool: T) {
+    server.registerTool(
+        tool.name,
+        {
+            description: tool.description,
+            inputSchema: {
+                ...tool.arguments?.shape,
+                ...tool.options?.shape,
+            },
+            annotations: {
+                // Hints client that tool is read-only (e.g. clients can use this information to determine if the tool can be used in planning mode)
+                readOnlyHint: true,
+                // Hints client that tool does not have access to external resources (e.g. internet, files, etc.)
+                openWorldHint: false,
+                // Hints client that tool is idempotent (can be called multiple times with the same input)
+                idempotentHint: true,
+                // Hints client that tool is not destructive (cannot change the state of the system)
+                destructiveHint: false,
+            },
+        },
+        args => {
+            trackToolCall(tool.name, args ?? {}, { invocationMethod: 'mcp' });
+
+            return {
+                content: tool.callback(args).map(text => ({
+                    type: 'text' as const,
+                    text,
+                })),
+            };
+        },
+    );
+}
+
+export function createServer() {
+    identify();
+
+    const server = new McpServer({
+        name: 'ds-ai-mcp',
+        version: pkg.version,
+    });
+
+    Object.values(tools).forEach(tool => registerTool(server, tool));
+
+    return server;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './create-server';

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../../tsconfig.json",
+    "include": ["src", "package.json", "vite.config.ts"],
+    "exclude": ["node_modules", "dist"],
+    "compilerOptions": {
+        "resolveJsonModule": true,
+        "module": "esnext",
+        "target": "esnext",
+        "types": ["vitest/globals", "node"]
+    }
+}

package/vite.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+
+export default defineConfig({
+    plugins: [dts({ exclude: ['vite.config.ts'], entryRoot: 'src' })],
+    build: {
+        target: 'esnext',
+        ssr: true,
+        lib: {
+            entry: ['src/index.ts', 'src/bin.ts'],
+            formats: ['es'],
+        },
+        rolldownOptions: {
+            output: {
+                entryFileNames: '[name].js',
+            },
+        },
+    },
+});