design-constraint-validator 2.0.1 → 2.1.0

package/mcp/contracts.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export declare const jsonValueSchema: z.ZodType<JsonValue>;
+export declare const jsonObjectSchema: z.ZodType<JsonObject>;
+export declare const tokenInputShape: {
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+};
+export declare const validateInputShape: {
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+};
+export declare const whyInputShape: {
+    tokenId: z.ZodString;
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+};
+export declare const graphInputShape: {
+    format: z.ZodOptional<z.ZodLiteral<"json">>;
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+};
+export declare const validateInputSchema: z.ZodObject<{
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+}, "strip", z.ZodTypeAny, {
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}, {
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}>;
+export declare const whyInputSchema: z.ZodObject<{
+    tokenId: z.ZodString;
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+}, "strip", z.ZodTypeAny, {
+    tokenId: string;
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}, {
+    tokenId: string;
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}>;
+export declare const graphInputSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodLiteral<"json">>;
+    tokens: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    tokensPath: z.ZodOptional<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodType<JsonObject, z.ZodTypeDef, JsonObject>>;
+    configPath: z.ZodOptional<z.ZodString>;
+    constraintsDir: z.ZodOptional<z.ZodString>;
+    breakpoint: z.ZodOptional<z.ZodEnum<["sm", "md", "lg"]>>;
+}, "strip", z.ZodTypeAny, {
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    format?: "json" | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}, {
+    tokens?: JsonObject | undefined;
+    constraints?: JsonObject | undefined;
+    format?: "json" | undefined;
+    constraintsDir?: string | undefined;
+    breakpoint?: "sm" | "md" | "lg" | undefined;
+    tokensPath?: string | undefined;
+    configPath?: string | undefined;
+}>;
+export type ValidateToolInput = z.infer<typeof validateInputSchema>;
+export type WhyToolInput = z.infer<typeof whyInputSchema>;
+export type GraphToolInput = z.infer<typeof graphInputSchema>;
+//# sourceMappingURL=contracts.d.ts.map

package/mcp/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,UAAU,GAAG,SAAS,EAAE,CAAC;AAEjE,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAID,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAEhD,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAA6B,CAAC;AAEjF,eAAO,MAAM,eAAe;;;;;;;CAW3B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;CAE9B,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;CAGzB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;CAG3B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAA+B,CAAC;AAChE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAA0B,CAAC;AACtD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAA4B,CAAC;AAE1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/mcp/contracts.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const jsonPrimitiveSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+export const jsonValueSchema = z.lazy(() => z.union([jsonPrimitiveSchema, z.array(jsonValueSchema), z.record(jsonValueSchema)]));
+export const jsonObjectSchema = z.record(jsonValueSchema);
+export const tokenInputShape = {
+    tokens: jsonObjectSchema
+        .optional()
+        .describe('Inline DTCG-style token tree. Takes precedence over tokensPath.'),
+    tokensPath: z.string().optional().describe('Path to a token JSON file on the server filesystem.'),
+    constraints: jsonObjectSchema
+        .optional()
+        .describe('Inline constraints block from dcv.config.json. Takes precedence over configPath.'),
+    configPath: z.string().optional().describe('Path to a JSON DCV config file.'),
+    constraintsDir: z.string().optional().describe('Directory holding order and cross-axis constraints.'),
+    breakpoint: z.enum(['sm', 'md', 'lg']).optional().describe('Optional constraint breakpoint.'),
+};
+export const validateInputShape = {
+    ...tokenInputShape,
+};
+export const whyInputShape = {
+    ...tokenInputShape,
+    tokenId: z.string().describe('Token id to explain, for example color.role.text.default.'),
+};
+export const graphInputShape = {
+    ...tokenInputShape,
+    format: z.literal('json').optional().describe('Only json is supported; omitted defaults to json.'),
+};
+export const validateInputSchema = z.object(validateInputShape);
+export const whyInputSchema = z.object(whyInputShape);
+export const graphInputSchema = z.object(graphInputShape);

package/mcp/contracts.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+
+const jsonPrimitiveSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+
+export const jsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([jsonPrimitiveSchema, z.array(jsonValueSchema), z.record(jsonValueSchema)]),
+);
+
+export const jsonObjectSchema: z.ZodType<JsonObject> = z.record(jsonValueSchema);
+
+export const tokenInputShape = {
+  tokens: jsonObjectSchema
+    .optional()
+    .describe('Inline DTCG-style token tree. Takes precedence over tokensPath.'),
+  tokensPath: z.string().optional().describe('Path to a token JSON file on the server filesystem.'),
+  constraints: jsonObjectSchema
+    .optional()
+    .describe('Inline constraints block from dcv.config.json. Takes precedence over configPath.'),
+  configPath: z.string().optional().describe('Path to a JSON DCV config file.'),
+  constraintsDir: z.string().optional().describe('Directory holding order and cross-axis constraints.'),
+  breakpoint: z.enum(['sm', 'md', 'lg']).optional().describe('Optional constraint breakpoint.'),
+};
+
+export const validateInputShape = {
+  ...tokenInputShape,
+};
+
+export const whyInputShape = {
+  ...tokenInputShape,
+  tokenId: z.string().describe('Token id to explain, for example color.role.text.default.'),
+};
+
+export const graphInputShape = {
+  ...tokenInputShape,
+  format: z.literal('json').optional().describe('Only json is supported; omitted defaults to json.'),
+};
+
+export const validateInputSchema = z.object(validateInputShape);
+export const whyInputSchema = z.object(whyInputShape);
+export const graphInputSchema = z.object(graphInputShape);
+
+export type ValidateToolInput = z.infer<typeof validateInputSchema>;
+export type WhyToolInput = z.infer<typeof whyInputSchema>;
+export type GraphToolInput = z.infer<typeof graphInputSchema>;

package/mcp/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export { graphInputSchema, graphInputShape, jsonObjectSchema, jsonValueSchema, validateInputSchema, validateInputShape, whyInputSchema, whyInputShape, } from './contracts.js';
+export type { GraphToolInput, JsonObject, JsonPrimitive, JsonValue, ValidateToolInput, WhyToolInput, } from './contracts.js';
+export { dcvMcpTools, graphTool, registerDcvMcpTools, ToolExecutionError, validateTool, whyTool, } from './tools.js';
+export type { DcvMcpToolName, GraphToolResult, ToolFailure, ToolResponse, WhyToolResult, } from './tools.js';
+export declare function createDcvMcpServer(): McpServer;
+export declare function startStdioServer(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,UAAU,EACV,aAAa,EACb,SAAS,EACT,iBAAiB,EACjB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EACX,SAAS,EACT,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,OAAO,GACR,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,cAAc,EACd,eAAe,EACf,WAAW,EACX,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,wBAAgB,kBAAkB,IAAI,SAAS,CAQ9C;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAItD"}

package/mcp/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerDcvMcpTools } from './tools.js';
+export { graphInputSchema, graphInputShape, jsonObjectSchema, jsonValueSchema, validateInputSchema, validateInputShape, whyInputSchema, whyInputShape, } from './contracts.js';
+export { dcvMcpTools, graphTool, registerDcvMcpTools, ToolExecutionError, validateTool, whyTool, } from './tools.js';
+export function createDcvMcpServer() {
+    const server = new McpServer({
+        name: 'dcv-mcp',
+        version: '2.1.0',
+    });
+    registerDcvMcpTools(server);
+    return server;
+}
+export async function startStdioServer() {
+    const server = createDcvMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+function isEntrypoint() {
+    const entry = process.argv[1];
+    return entry !== undefined && resolve(fileURLToPath(import.meta.url)) === resolve(entry);
+}
+if (isEntrypoint()) {
+    startStdioServer().catch((error) => {
+        const message = error instanceof Error ? error.message : 'Unknown MCP server failure';
+        console.error(`[dcv-mcp] ${message}`);
+        process.exitCode = 1;
+    });
+}

package/mcp/index.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+import { registerDcvMcpTools } from './tools.js';
+
+export {
+  graphInputSchema,
+  graphInputShape,
+  jsonObjectSchema,
+  jsonValueSchema,
+  validateInputSchema,
+  validateInputShape,
+  whyInputSchema,
+  whyInputShape,
+} from './contracts.js';
+export type {
+  GraphToolInput,
+  JsonObject,
+  JsonPrimitive,
+  JsonValue,
+  ValidateToolInput,
+  WhyToolInput,
+} from './contracts.js';
+export {
+  dcvMcpTools,
+  graphTool,
+  registerDcvMcpTools,
+  ToolExecutionError,
+  validateTool,
+  whyTool,
+} from './tools.js';
+export type {
+  DcvMcpToolName,
+  GraphToolResult,
+  ToolFailure,
+  ToolResponse,
+  WhyToolResult,
+} from './tools.js';
+
+export function createDcvMcpServer(): McpServer {
+  const server = new McpServer({
+    name: 'dcv-mcp',
+    version: '2.1.0',
+  });
+
+  registerDcvMcpTools(server);
+  return server;
+}
+
+export async function startStdioServer(): Promise<void> {
+  const server = createDcvMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+function isEntrypoint(): boolean {
+  const entry = process.argv[1];
+  return entry !== undefined && resolve(fileURLToPath(import.meta.url)) === resolve(entry);
+}
+
+if (isEntrypoint()) {
+  startStdioServer().catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : 'Unknown MCP server failure';
+    console.error(`[dcv-mcp] ${message}`);
+    process.exitCode = 1;
+  });
+}

package/mcp/tools.d.ts

@@ -0,0 +1,52 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { z } from 'zod';
+import { type WhyReport } from '../core/why.js';
+import { type ValidateResult } from '../cli/validate-api.js';
+import type { ValidateToolInput, WhyToolInput, GraphToolInput } from './contracts.js';
+export type DcvMcpToolName = 'validate' | 'why' | 'graph';
+export interface ToolFailure {
+    ok: false;
+    tool: DcvMcpToolName;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export type ToolResponse<T extends {
+    ok: boolean;
+} & object> = ({
+    tool: DcvMcpToolName;
+} & T) | ToolFailure;
+export declare class ToolExecutionError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export interface GraphToolResult {
+    ok: true;
+    nodes: string[];
+    edges: Array<[string, string]>;
+    meta: {
+        nodeCount: number;
+        edgeCount: number;
+    };
+}
+export type WhyToolResult = {
+    ok: true;
+} & WhyReport;
+interface ToolDefinition<TInput, TResult extends {
+    ok: boolean;
+} & object> {
+    name: DcvMcpToolName;
+    description: string;
+    inputSchema: Record<string, z.ZodTypeAny>;
+    handler: (input: TInput) => Promise<ToolResponse<TResult>> | ToolResponse<TResult>;
+}
+export declare function validateTool(input: ValidateToolInput): Promise<ToolResponse<ValidateResult>>;
+export declare function whyTool(input: WhyToolInput): Promise<ToolResponse<WhyToolResult>>;
+export declare function graphTool(input: GraphToolInput): Promise<ToolResponse<GraphToolResult>>;
+export declare const dcvMcpTools: Array<ToolDefinition<ValidateToolInput, ValidateResult> | ToolDefinition<WhyToolInput, WhyToolResult> | ToolDefinition<GraphToolInput, GraphToolResult>>;
+export declare function registerDcvMcpTools(server: McpServer): void;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/mcp/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAI7B,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAGvE,OAAO,KAAK,EAAc,iBAAiB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGlG,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,KAAK,GAAG,OAAO,CAAC;AAE1D,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC,CAAC;CACH;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,IAAI,CAAC;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;AAE5G,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAE/B,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAK7E;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/B,IAAI,EAAE;QACJ,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG,SAAS,CAAC;AAWrD,UAAU,cAAc,CAAC,MAAM,EAAE,OAAO,SAAS;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM;IACvE,IAAI,EAAE,cAAc,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;IAC1C,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;CACpF;AAyFD,wBAAsB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC,CAelG;AAED,wBAAsB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAevF;AAED,wBAAsB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,eAAe,CAAC,CAAC,CAe7F;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAC3B,cAAc,CAAC,iBAAiB,EAAE,cAAc,CAAC,GACjD,cAAc,CAAC,YAAY,EAAE,aAAa,CAAC,GAC3C,cAAc,CAAC,cAAc,EAAE,eAAe,CAAC,CAoBlD,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAuB3D"}

package/mcp/tools.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import { suggestIds } from '../core/cli-format.js';
+import { flattenTokens } from '../core/flatten.js';
+import { explain } from '../core/why.js';
+import { validate } from '../cli/validate-api.js';
+import { graphInputShape, validateInputShape, whyInputShape } from './contracts.js';
+export class ToolExecutionError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown tool failure';
+}
+function toFailure(tool, error) {
+    if (error instanceof ToolExecutionError) {
+        return {
+            ok: false,
+            tool,
+            error: {
+                code: error.code,
+                message: error.message,
+                ...(error.details ? { details: error.details } : {}),
+            },
+        };
+    }
+    return {
+        ok: false,
+        tool,
+        error: {
+            code: 'tool_execution_failed',
+            message: errorMessage(error),
+        },
+    };
+}
+async function executeTool(tool, fn) {
+    try {
+        return {
+            tool,
+            ...(await fn()),
+        };
+    }
+    catch (error) {
+        return toFailure(tool, error);
+    }
+}
+function isToolFailure(result) {
+    return result.ok === false && 'error' in result;
+}
+function responseToContent(result) {
+    return JSON.stringify(result, null, 2);
+}
+function parseJsonFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new ToolExecutionError('tokens_not_found', `Tokens file not found: ${filePath}`);
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        throw new ToolExecutionError('invalid_tokens', `Tokens file is not valid JSON: ${filePath}`, {
+            cause: errorMessage(error),
+        });
+    }
+}
+function asJsonObject(value, label) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    throw new ToolExecutionError('invalid_input', `${label} must be a JSON object.`);
+}
+function resolveTokens(input) {
+    if (input.tokens !== undefined) {
+        return input.tokens;
+    }
+    if (input.tokensPath !== undefined) {
+        return asJsonObject(parseJsonFile(input.tokensPath), 'tokensPath contents');
+    }
+    throw new ToolExecutionError('invalid_input', 'Provide either tokens or tokensPath.');
+}
+function constraints(input) {
+    return input.constraints;
+}
+export async function validateTool(input) {
+    return executeTool('validate', () => {
+        if (input.tokens === undefined && input.tokensPath === undefined) {
+            throw new ToolExecutionError('invalid_input', 'Provide either tokens or tokensPath.');
+        }
+        return validate({
+            ...(input.tokens !== undefined ? { tokens: input.tokens } : {}),
+            ...(input.tokens === undefined && input.tokensPath !== undefined ? { tokensPath: input.tokensPath } : {}),
+            ...(input.constraints !== undefined ? { constraints: constraints(input) } : {}),
+            ...(input.configPath !== undefined ? { configPath: input.configPath } : {}),
+            ...(input.constraintsDir !== undefined ? { constraintsDir: input.constraintsDir } : {}),
+            ...(input.breakpoint !== undefined ? { breakpoint: input.breakpoint } : {}),
+        });
+    });
+}
+export async function whyTool(input) {
+    return executeTool('why', () => {
+        const { flat, edges } = flattenTokens(resolveTokens(input));
+        if (!Object.prototype.hasOwnProperty.call(flat, input.tokenId)) {
+            throw new ToolExecutionError('unknown_token', `Unknown token id: ${input.tokenId}`, {
+                tokenId: input.tokenId,
+                suggestions: suggestIds(input.tokenId, Object.keys(flat)).map((suggestion) => suggestion.id),
+            });
+        }
+        return {
+            ok: true,
+            ...explain(input.tokenId, flat, edges),
+        };
+    });
+}
+export async function graphTool(input) {
+    return executeTool('graph', () => {
+        const { flat, edges } = flattenTokens(resolveTokens(input));
+        const nodes = Object.keys(flat).sort();
+        return {
+            ok: true,
+            nodes,
+            edges,
+            meta: {
+                nodeCount: nodes.length,
+                edgeCount: edges.length,
+            },
+        };
+    });
+}
+export const dcvMcpTools = [
+    {
+        name: 'validate',
+        description: 'Validate DTCG-style design tokens against DCV constraints and return structured violations.',
+        inputSchema: validateInputShape,
+        handler: validateTool,
+    },
+    {
+        name: 'why',
+        description: 'Explain token provenance, aliases, immediate dependencies, dependents, and alias chain.',
+        inputSchema: whyInputShape,
+        handler: whyTool,
+    },
+    {
+        name: 'graph',
+        description: 'Return the token dependency graph as nodes and directed edges.',
+        inputSchema: graphInputShape,
+        handler: graphTool,
+    },
+];
+export function registerDcvMcpTools(server) {
+    for (const tool of dcvMcpTools) {
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }, async (input) => {
+            const result = await tool.handler(input);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseToContent(result),
+                    },
+                ],
+                structuredContent: result,
+                ...(isToolFailure(result) ? { isError: true } : {}),
+            };
+        });
+    }
+}