lanestyle-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+# LaneStyle MCP Server
+
+让 AI Agent 直接操作车道级图层样式配置的 MCP Server。
+
+[![npm version](https://badge.fury.io/js/lanestyle-mcp-server.svg)](https://www.npmjs.com/package/lanestyle-mcp-server)
+
+## 安装
+
+### 方式一：npm 全局安装（推荐）
+
+```bash
+npm install -g lanestyle-mcp-server
+```
+
+### 方式二：本地安装
+
+```bash
+git clone https://github.com/your-username/lanestyle-mcp-server.git
+cd lanestyle-mcp-server
+npm install
+npm run build
+```
+
+## 配置 AI 客户端
+
+### Qoder
+
+编辑 `~/.qoder/mcp.json`：
+
+```json
+{
+  "mcpServers": {
+    "lanestyle": {
+      "command": "lanestyle-mcp",
+      "env": {
+        "LANESTYLE_PROJECT_ROOT": "/path/to/your/lanestyle/project"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+编辑 `~/Library/Application Support/Claude/claude_desktop_config.json`：
+
+```json
+{
+  "mcpServers": {
+    "lanestyle": {
+      "command": "lanestyle-mcp",
+      "env": {
+        "LANESTYLE_PROJECT_ROOT": "/path/to/your/lanestyle/project"
+      }
+    }
+  }
+}
+```
+
+> **注意**：`LANESTYLE_PROJECT_ROOT` 需要指向包含 `json/` 目录的项目根目录
+
+## 可用工具
+
+| 工具名 | 功能 | 示例 |
+|--------|------|------|
+| `list_config_files` | 列出所有配置文件 | - |
+| `search_fields` | 搜索字段（按名称或注释） | 搜索 "tmc" 找路况颜色 |
+| `list_color_fields` | 列出所有颜色字段 | - |
+| `get_field` | 获取字段值 | 获取某个颜色的当前值 |
+| `set_field` | 设置字段值 | 修改颜色为 #FF0000 |
+| `batch_update_colors` | 批量更新颜色 | 统一修改所有拥堵颜色 |
+| `convert_color` | 颜色格式转换 | 十进制 ↔ 十六进制 |
+
+## 使用示例
+
+### 与 AI 对话
+
+```
+你: "把所有交通拥堵的颜色改成更深的红色"
+
+AI 会自动:
+1. 调用 search_fields 搜索 "拥堵" 或 "Congested"
+2. 调用 get_field 查看当前值
+3. 调用 batch_update_colors 批量修改
+```
+
+### 颜色格式
+
+- 输入支持: `#RRGGBB` 或 `#AARRGGBB`
+- 内部存储: 32位十进制 ARGB (如 4289941584)
+- Alpha 255 = 不透明，0 = 完全透明
+
+## 配置文件说明
+
+| 文件名 | 描述 |
+|--------|------|
+| LaneRoadPolygonStyleConfig | 车道引导面样式 - TMC路况颜色等 |
+| LaneDragLineStyleConfig | 牵引线样式 |
+| LaneSurfaceArrowStyle | 箭头样式 |
+
+## 开发
+
+```bash
+# 开发模式（热重载）
+npm run dev
+
+# 构建
+npm run build
+
+# 启动
+npm start
+```

package/dist/config-tools.d.ts

@@ -0,0 +1,102 @@
+/**
+ * LaneStyle 配置文件工具
+ * 提供 JSONC 配置文件的读写、字段查询和颜色转换功能
+ */
+export interface ARGB {
+    a: number;
+    r: number;
+    g: number;
+    b: number;
+}
+export interface FieldInfo {
+    path: string;
+    value: unknown;
+    type: string;
+    comment?: string;
+    hexColor?: string;
+}
+export interface ConfigFile {
+    name: string;
+    path: string;
+    description: string;
+}
+/**
+ * 将32位十进制ARGB转换为ARGB对象
+ */
+export declare function decToARGB(dec: number | string): ARGB;
+/**
+ * 将ARGB对象转换为32位十进制数字
+ */
+export declare function argbToDec(argb: ARGB): number;
+/**
+ * ARGB转Hex (#AARRGGBB 或 #RRGGBB)
+ */
+export declare function argbToHex(argb: ARGB, includeAlpha?: boolean): string;
+/**
+ * Hex转ARGB，支持 #RRGGBB 和 #AARRGGBB 格式
+ */
+export declare function hexToARGB(hex: string): ARGB | null;
+/**
+ * 判断数值是否可能是颜色值
+ * 结合字段路径名称判断，避免误判大数字
+ */
+export declare function isLikelyColor(value: unknown, fieldPath?: string): boolean;
+/**
+ * 移除 JSONC 中的注释，返回纯 JSON
+ */
+export declare function stripJsonComments(jsonc: string): string;
+/**
+ * 提取 JSONC 中的注释，返回路径到注释的映射
+ */
+export declare function extractComments(jsonc: string): Map<string, string>;
+/**
+ * 读取配置文件
+ */
+export declare function readConfigFile(filePath: string): {
+    data: Record<string, unknown>;
+    comments: Map<string, string>;
+    rawContent: string;
+};
+/**
+ * 在 JSONC 内容中替换指定字段的值（保留注释和格式）
+ */
+export declare function replaceValueInJsonc(content: string, fieldPath: string, newValue: unknown): string;
+/**
+ * 保存配置文件（保留原始格式和注释）
+ * @param filePath 文件路径
+ * @param originalContent 原始文件内容
+ * @param modifications 修改列表 [{path, value}]
+ */
+export declare function saveConfigFileWithComments(filePath: string, originalContent: string, modifications: Array<{
+    path: string;
+    value: unknown;
+}>): void;
+/**
+ * 保存配置文件（简单方式，会丢失注释）
+ * @deprecated 使用 saveConfigFileWithComments 代替
+ */
+export declare function saveConfigFile(filePath: string, data: Record<string, unknown>): void;
+/**
+ * 获取字段值（支持嵌套路径）
+ */
+export declare function getFieldValue(data: Record<string, unknown>, fieldPath: string): unknown;
+/**
+ * 设置字段值（支持嵌套路径）
+ */
+export declare function setFieldValue(data: Record<string, unknown>, fieldPath: string, value: unknown): void;
+/**
+ * 递归遍历所有字段
+ */
+export declare function traverseFields(data: unknown, callback: (path: string, value: unknown, type: string) => void, prefix?: string): void;
+/**
+ * 搜索字段（支持模糊匹配）
+ */
+export declare function searchFields(data: Record<string, unknown>, query: string, comments: Map<string, string>): FieldInfo[];
+/**
+ * 列出所有颜色字段
+ */
+export declare function listColorFields(data: Record<string, unknown>, comments: Map<string, string>): FieldInfo[];
+/**
+ * 获取可用的配置文件列表
+ */
+export declare function listConfigFiles(baseDir: string): ConfigFile[];

package/dist/config-tools.js

@@ -0,0 +1,384 @@
+/**
+ * LaneStyle 配置文件工具
+ * 提供 JSONC 配置文件的读写、字段查询和颜色转换功能
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// ============= 颜色转换 =============
+/**
+ * 将32位十进制ARGB转换为ARGB对象
+ */
+export function decToARGB(dec) {
+    const big = BigInt(dec);
+    const a = Number((big >> 24n) & 255n);
+    const r = Number((big >> 16n) & 255n);
+    const g = Number((big >> 8n) & 255n);
+    const b = Number(big & 255n);
+    return { a, r, g, b };
+}
+/**
+ * 将ARGB对象转换为32位十进制数字
+ */
+export function argbToDec(argb) {
+    const big = (BigInt(argb.a) << 24n) |
+        (BigInt(argb.r) << 16n) |
+        (BigInt(argb.g) << 8n) |
+        BigInt(argb.b);
+    return Number(big);
+}
+/**
+ * ARGB转Hex (#AARRGGBB 或 #RRGGBB)
+ */
+export function argbToHex(argb, includeAlpha = true) {
+    const a = argb.a.toString(16).padStart(2, '0').toUpperCase();
+    const r = argb.r.toString(16).padStart(2, '0').toUpperCase();
+    const g = argb.g.toString(16).padStart(2, '0').toUpperCase();
+    const b = argb.b.toString(16).padStart(2, '0').toUpperCase();
+    return includeAlpha ? `#${a}${r}${g}${b}` : `#${r}${g}${b}`;
+}
+/**
+ * Hex转ARGB，支持 #RRGGBB 和 #AARRGGBB 格式
+ */
+export function hexToARGB(hex) {
+    let cleanHex = hex.replace('#', '').toUpperCase();
+    if (cleanHex.length === 6) {
+        cleanHex = 'FF' + cleanHex; // 默认不透明
+    }
+    if (cleanHex.length !== 8) {
+        return null;
+    }
+    const a = parseInt(cleanHex.substring(0, 2), 16);
+    const r = parseInt(cleanHex.substring(2, 4), 16);
+    const g = parseInt(cleanHex.substring(4, 6), 16);
+    const b = parseInt(cleanHex.substring(6, 8), 16);
+    if (isNaN(a) || isNaN(r) || isNaN(g) || isNaN(b)) {
+        return null;
+    }
+    return { a, r, g, b };
+}
+/**
+ * 判断数值是否可能是颜色值
+ * 结合字段路径名称判断，避免误判大数字
+ */
+export function isLikelyColor(value, fieldPath) {
+    if (typeof value !== 'number')
+        return false;
+    // 颜色值通常 > 16777215 (0xFFFFFF) 且 <= 4294967295 (0xFFFFFFFF)
+    const inColorRange = value > 16777215 && value <= 4294967295;
+    if (!inColorRange)
+        return false;
+    // 如果提供了字段路径，检查是否包含颜色相关关键词
+    if (fieldPath) {
+        const colorKeywords = ['color', 'Color', 'COLOR', 'tmc', 'Tmc', 'TMC'];
+        return colorKeywords.some(keyword => fieldPath.includes(keyword));
+    }
+    return inColorRange;
+}
+// ============= JSONC 解析 =============
+/**
+ * 移除 JSONC 中的注释，返回纯 JSON
+ */
+export function stripJsonComments(jsonc) {
+    let result = '';
+    let i = 0;
+    let inString = false;
+    let stringChar = '';
+    while (i < jsonc.length) {
+        const char = jsonc[i];
+        const nextChar = jsonc[i + 1];
+        if (inString) {
+            result += char;
+            if (char === '\\' && i + 1 < jsonc.length) {
+                result += nextChar;
+                i += 2;
+                continue;
+            }
+            if (char === stringChar) {
+                inString = false;
+            }
+            i++;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+            result += char;
+            i++;
+            continue;
+        }
+        // 单行注释
+        if (char === '/' && nextChar === '/') {
+            while (i < jsonc.length && jsonc[i] !== '\n') {
+                i++;
+            }
+            continue;
+        }
+        // 多行注释
+        if (char === '/' && nextChar === '*') {
+            i += 2;
+            while (i < jsonc.length - 1 && !(jsonc[i] === '*' && jsonc[i + 1] === '/')) {
+                i++;
+            }
+            i += 2;
+            continue;
+        }
+        result += char;
+        i++;
+    }
+    return result;
+}
+/**
+ * 提取 JSONC 中的注释，返回路径到注释的映射
+ */
+export function extractComments(jsonc) {
+    const comments = new Map();
+    const lines = jsonc.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const commentMatch = line.match(/\/\/\s*(.+)$/);
+        if (commentMatch) {
+            // 提取该行的键名
+            const keyMatch = line.match(/"([^"]+)"\s*:/);
+            if (keyMatch) {
+                comments.set(keyMatch[1], commentMatch[1].trim());
+            }
+        }
+    }
+    return comments;
+}
+// ============= 配置文件操作 =============
+/**
+ * 读取配置文件
+ */
+export function readConfigFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const comments = extractComments(content);
+    const jsonStr = stripJsonComments(content);
+    const data = JSON.parse(jsonStr);
+    return { data, comments, rawContent: content };
+}
+/**
+ * 在 JSONC 内容中替换指定字段的值（保留注释和格式）
+ */
+export function replaceValueInJsonc(content, fieldPath, newValue) {
+    const parts = fieldPath.replace(/\[(\d+)\]/g, '.$1').split('.');
+    let result = content;
+    // 构建查找模式：需要找到最后一个键名对应的值
+    const lastKey = parts[parts.length - 1];
+    // 如果最后一个 part 是数字（数组索引），需要特殊处理
+    if (/^\d+$/.test(lastKey)) {
+        // 数组元素的情况比较复杂，使用简单的 JSON 替换可能更安全
+        // 这里我们需要找到数组中的特定元素并替换
+        // 暂时使用完整路径搜索
+        return replaceArrayElementValue(content, fieldPath, newValue);
+    }
+    // 对象属性的情况：查找 "keyName": value 并替换 value
+    // 创建一个正则表达式来匹配这个键及其值
+    const keyPattern = `"${lastKey}"\\s*:\\s*`;
+    // 匹配值的模式（数字、字符串、布尔值、null）
+    const valuePattern = `(-?\\d+\\.?\\d*|"[^"]*"|true|false|null)`;
+    const regex = new RegExp(`(${keyPattern})(${valuePattern})`, 'g');
+    // 将新值转换为 JSON 字符串
+    const newValueStr = typeof newValue === 'string' ? `"${newValue}"` : String(newValue);
+    // 替换所有匹配项（注意：如果有多个同名字段，都会被替换）
+    // 为了更精确，我们应该只替换特定路径的字段，但这需要更复杂的解析
+    // 这里简化处理，假设字段名在上下文中是唯一的
+    result = result.replace(regex, `$1${newValueStr}`);
+    return result;
+}
+/**
+ * 替换数组元素中的值
+ */
+function replaceArrayElementValue(content, fieldPath, newValue) {
+    // 解析路径，找到数组和索引
+    const parts = fieldPath.replace(/\[(\d+)\]/g, '.$1').split('.');
+    // 简化处理：直接使用 JSON 解析和重新序列化的方式
+    // 但保留原始内容的行结构
+    const jsonStr = stripJsonComments(content);
+    const data = JSON.parse(jsonStr);
+    setFieldValue(data, fieldPath, newValue);
+    // 尝试智能替换：找到值的位置并替换
+    // 这里使用简单的方法：找到最后一个键名，替换其值
+    const lastKey = parts[parts.length - 1];
+    const secondLastKey = parts.length >= 2 ? parts[parts.length - 2] : null;
+    if (secondLastKey && /^\d+$/.test(lastKey)) {
+        // 最后是数组索引的情况，找到倒数第二个键
+        const keyPattern = `"${secondLastKey}"\\s*:\\s*`;
+        const valuePattern = `(-?\\d+\\.?\\d*|"[^"]*"|true|false|null)`;
+        const regex = new RegExp(`(${keyPattern})(${valuePattern})`, 'g');
+        const newValueStr = typeof newValue === 'string' ? `"${newValue}"` : String(newValue);
+        return content.replace(regex, `$1${newValueStr}`);
+    }
+    // 如果都找不到，退回到简单替换（可能丢失部分格式）
+    return content;
+}
+/**
+ * 保存配置文件（保留原始格式和注释）
+ * @param filePath 文件路径
+ * @param originalContent 原始文件内容
+ * @param modifications 修改列表 [{path, value}]
+ */
+export function saveConfigFileWithComments(filePath, originalContent, modifications) {
+    let content = originalContent;
+    for (const mod of modifications) {
+        content = replaceValueInJsonc(content, mod.path, mod.value);
+    }
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+/**
+ * 保存配置文件（简单方式，会丢失注释）
+ * @deprecated 使用 saveConfigFileWithComments 代替
+ */
+export function saveConfigFile(filePath, data) {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+/**
+ * 获取字段值（支持嵌套路径）
+ */
+export function getFieldValue(data, fieldPath) {
+    const parts = fieldPath.replace(/\[(\d+)\]/g, '.$1').split('.');
+    let current = data;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current === 'object') {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+/**
+ * 设置字段值（支持嵌套路径）
+ */
+export function setFieldValue(data, fieldPath, value) {
+    const parts = fieldPath.replace(/\[(\d+)\]/g, '.$1').split('.');
+    let current = data;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const nextPart = parts[i + 1];
+        const isNextPartArrayIndex = /^\d+$/.test(nextPart);
+        if (Array.isArray(current)) {
+            const index = parseInt(part, 10);
+            if (current[index] === undefined || current[index] === null) {
+                current[index] = isNextPartArrayIndex ? [] : {};
+            }
+            current = current[index];
+        }
+        else {
+            if (!(part in current)) {
+                // 根据下一个 part 是否是数字来决定创建数组还是对象
+                current[part] = isNextPartArrayIndex ? [] : {};
+            }
+            current = current[part];
+        }
+    }
+    const lastPart = parts[parts.length - 1];
+    if (Array.isArray(current)) {
+        const index = parseInt(lastPart, 10);
+        current[index] = value;
+    }
+    else {
+        current[lastPart] = value;
+    }
+}
+/**
+ * 递归遍历所有字段
+ */
+export function traverseFields(data, callback, prefix = '') {
+    if (data === null || data === undefined)
+        return;
+    if (Array.isArray(data)) {
+        data.forEach((item, index) => {
+            const currentPath = `${prefix}[${index}]`;
+            traverseFields(item, callback, currentPath);
+        });
+    }
+    else if (typeof data === 'object') {
+        for (const [key, value] of Object.entries(data)) {
+            const currentPath = prefix ? `${prefix}.${key}` : key;
+            if (typeof value === 'object' && value !== null) {
+                traverseFields(value, callback, currentPath);
+            }
+            else {
+                // 传入完整路径用于颜色判断
+                const type = isLikelyColor(value, currentPath) ? 'color' : typeof value;
+                callback(currentPath, value, type);
+            }
+        }
+    }
+}
+/**
+ * 搜索字段（支持模糊匹配）
+ */
+export function searchFields(data, query, comments) {
+    const results = [];
+    const queryLower = query.toLowerCase();
+    traverseFields(data, (path, value, type) => {
+        const pathLower = path.toLowerCase();
+        const comment = comments.get(path.split('.').pop() || '');
+        const commentLower = comment?.toLowerCase() || '';
+        if (pathLower.includes(queryLower) || commentLower.includes(queryLower)) {
+            const fieldInfo = {
+                path,
+                value,
+                type,
+                comment
+            };
+            if (type === 'color' && typeof value === 'number') {
+                fieldInfo.hexColor = argbToHex(decToARGB(value));
+            }
+            results.push(fieldInfo);
+        }
+    });
+    return results;
+}
+/**
+ * 列出所有颜色字段
+ */
+export function listColorFields(data, comments) {
+    const results = [];
+    traverseFields(data, (path, value, type) => {
+        if (type === 'color' && typeof value === 'number') {
+            results.push({
+                path,
+                value,
+                type,
+                comment: comments.get(path.split('.').pop() || ''),
+                hexColor: argbToHex(decToARGB(value))
+            });
+        }
+    });
+    return results;
+}
+/**
+ * 获取可用的配置文件列表
+ */
+export function listConfigFiles(baseDir) {
+    const jsonDir = path.join(baseDir, 'json');
+    const files = [];
+    if (fs.existsSync(jsonDir)) {
+        const entries = fs.readdirSync(jsonDir);
+        for (const entry of entries) {
+            if (entry.endsWith('.data')) {
+                const name = entry.replace('.data', '');
+                files.push({
+                    name,
+                    path: path.join(jsonDir, entry),
+                    description: getConfigDescription(name)
+                });
+            }
+        }
+    }
+    return files;
+}
+function getConfigDescription(name) {
+    const descriptions = {
+        'LaneRoadPolygonStyleConfig': '车道引导面样式配置 - 包含引导面颜色、TMC路况颜色等',
+        'LaneDragLineStyleConfig': '牵引线样式配置 - 包含牵引线颜色、宽度等',
+        'LaneSurfaceArrowStyle': '箭头样式配置 - 包含箭头颜色、尺寸等'
+    };
+    return descriptions[name] || '样式配置文件';
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * LaneStyle MCP Server
+ *
+ * 为 AI Agent 提供车道级图层样式编辑能力
+ * 支持的功能：
+ * - 列出配置文件
+ * - 搜索字段
+ * - 读取/修改字段值
+ * - 颜色转换（十进制ARGB <-> 十六进制）
+ * - 批量更新
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+/**
+ * LaneStyle MCP Server
+ *
+ * 为 AI Agent 提供车道级图层样式编辑能力
+ * 支持的功能：
+ * - 列出配置文件
+ * - 搜索字段
+ * - 读取/修改字段值
+ * - 颜色转换（十进制ARGB <-> 十六进制）
+ * - 批量更新
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import { readConfigFile, saveConfigFileWithComments, getFieldValue, searchFields, listColorFields, listConfigFiles, hexToARGB, argbToDec, argbToHex, decToARGB, isLikelyColor, } from './config-tools.js';
+// 项目根目录
+const PROJECT_ROOT = process.env.LANESTYLE_PROJECT_ROOT || path.resolve(process.cwd(), '..');
+// 创建 MCP Server
+const server = new Server({
+    name: 'lanestyle-mcp-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+// ============= 工具定义 =============
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'list_config_files',
+                description: '列出所有可用的样式配置文件',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'search_fields',
+                description: '搜索配置字段。支持按字段名或注释内容搜索。例如搜索"tmc"可找到所有路况相关颜色字段',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        config_file: {
+                            type: 'string',
+                            description: '配置文件名（不含扩展名），如 LaneRoadPolygonStyleConfig',
+                        },
+                        query: {
+                            type: 'string',
+                            description: '搜索关键词，支持字段名或注释内容',
+                        },
+                    },
+                    required: ['config_file', 'query'],
+                },
+            },
+            {
+                name: 'list_color_fields',
+                description: '列出配置文件中所有颜色字段及其当前值（同时显示十进制和十六进制）',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        config_file: {
+                            type: 'string',
+                            description: '配置文件名（不含扩展名）',
+                        },
+                    },
+                    required: ['config_file'],
+                },
+            },
+            {
+                name: 'get_field',
+                description: '获取指定字段的当前值。如果是颜色值，会同时返回十进制和十六进制格式',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        config_file: {
+                            type: 'string',
+                            description: '配置文件名（不含扩展名）',
+                        },
+                        field_path: {
+                            type: 'string',
+                            description: '字段路径，如 surfecelinColor[0].borderTmcColorDay.tmcColorSlow',
+                        },
+                    },
+                    required: ['config_file', 'field_path'],
+                },
+            },
+            {
+                name: 'set_field',
+                description: '设置指定字段的值。颜色值支持十六进制格式（如 #FF0000 或 #80FF0000），会自动转换为32位十进制',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        config_file: {
+                            type: 'string',
+                            description: '配置文件名（不含扩展名）',
+                        },
+                        field_path: {
+                            type: 'string',
+                            description: '字段路径',
+                        },
+                        value: {
+                            type: ['string', 'number', 'boolean'],
+                            description: '新值。颜色可用十六进制格式（#RRGGBB 或 #AARRGGBB），数字直接输入',
+                        },
+                    },
+                    required: ['config_file', 'field_path', 'value'],
+                },
+            },
+            {
+                name: 'batch_update_colors',
+                description: '批量更新颜色字段。适合统一修改同类颜色（如所有拥堵颜色）',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        config_file: {
+                            type: 'string',
+                            description: '配置文件名（不含扩展名）',
+                        },
+                        updates: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    field_path: { type: 'string' },
+                                    value: { type: 'string', description: '十六进制颜色值' },
+                                },
+                                required: ['field_path', 'value'],
+                            },
+                            description: '更新列表，每项包含 field_path 和 value',
+                        },
+                    },
+                    required: ['config_file', 'updates'],
+                },
+            },
+            {
+                name: 'convert_color',
+                description: '颜色格式转换工具。在十进制ARGB和十六进制之间转换',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        value: {
+                            type: ['string', 'number'],
+                            description: '输入值：十进制数字（如 4289941584）或十六进制字符串（如 #FFCC0000）',
+                        },
+                    },
+                    required: ['value'],
+                },
+            },
+        ],
+    };
+});
+// ============= 工具实现 =============
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'list_config_files': {
+                const files = listConfigFiles(PROJECT_ROOT);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(files, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'search_fields': {
+                const configFile = args?.config_file;
+                const query = args?.query;
+                // 参数验证
+                if (!configFile) {
+                    throw new Error('缺少参数: config_file');
+                }
+                if (!query) {
+                    throw new Error('缺少参数: query');
+                }
+                const filePath = path.join(PROJECT_ROOT, 'json', `${configFile}.data`);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`配置文件不存在: ${configFile}`);
+                }
+                const { data, comments } = readConfigFile(filePath);
+                const results = searchFields(data, query, comments);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `找到 ${results.length} 个匹配字段:\n${JSON.stringify(results, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            case 'list_color_fields': {
+                const configFile = args?.config_file;
+                // 参数验证
+                if (!configFile) {
+                    throw new Error('缺少参数: config_file');
+                }
+                const filePath = path.join(PROJECT_ROOT, 'json', `${configFile}.data`);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`配置文件不存在: ${configFile}`);
+                }
+                const { data, comments } = readConfigFile(filePath);
+                const colors = listColorFields(data, comments);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `共 ${colors.length} 个颜色字段:\n${JSON.stringify(colors, null, 2)}`,
+                        },
+                    ],
+                };
+            }
+            case 'get_field': {
+                const configFile = args?.config_file;
+                const fieldPath = args?.field_path;
+                // 参数验证
+                if (!configFile) {
+                    throw new Error('缺少参数: config_file');
+                }
+                if (!fieldPath) {
+                    throw new Error('缺少参数: field_path');
+                }
+                const filePath = path.join(PROJECT_ROOT, 'json', `${configFile}.data`);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`配置文件不存在: ${configFile}`);
+                }
+                const { data, comments } = readConfigFile(filePath);
+                const value = getFieldValue(data, fieldPath);
+                if (value === undefined) {
+                    throw new Error(`字段不存在: ${fieldPath}`);
+                }
+                const result = {
+                    path: fieldPath,
+                    value,
+                    type: isLikelyColor(value, fieldPath) ? 'color' : typeof value,
+                    comment: comments.get(fieldPath.split('.').pop() || ''),
+                };
+                if (isLikelyColor(value, fieldPath) && typeof value === 'number') {
+                    result.hexColor = argbToHex(decToARGB(value));
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'set_field': {
+                const configFile = args?.config_file;
+                const fieldPath = args?.field_path;
+                let value = args?.value;
+                // 参数验证
+                if (!configFile) {
+                    throw new Error('缺少参数: config_file');
+                }
+                if (!fieldPath) {
+                    throw new Error('缺少参数: field_path');
+                }
+                if (value === undefined || value === null) {
+                    throw new Error('缺少参数: value');
+                }
+                const filePath = path.join(PROJECT_ROOT, 'json', `${configFile}.data`);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`配置文件不存在: ${configFile}`);
+                }
+                // 如果值是十六进制颜色，转换为十进制
+                if (typeof value === 'string' && value.startsWith('#')) {
+                    const argb = hexToARGB(value);
+                    if (!argb) {
+                        throw new Error(`无效的颜色格式: ${value}`);
+                    }
+                    value = argbToDec(argb);
+                }
+                const { data, rawContent } = readConfigFile(filePath);
+                const oldValue = getFieldValue(data, fieldPath);
+                // 使用保留注释的方式保存
+                saveConfigFileWithComments(filePath, rawContent, [{ path: fieldPath, value }]);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `已更新字段 ${fieldPath}:\n旧值: ${oldValue}${isLikelyColor(oldValue, fieldPath) ? ` (${argbToHex(decToARGB(oldValue))})` : ''}\n新值: ${value}${isLikelyColor(value, fieldPath) ? ` (${argbToHex(decToARGB(value))})` : ''}`,
+                        },
+                    ],
+                };
+            }
+            case 'batch_update_colors': {
+                const configFile = args?.config_file;
+                const updates = args?.updates;
+                // 参数验证
+                if (!configFile) {
+                    throw new Error('缺少参数: config_file');
+                }
+                if (!updates || !Array.isArray(updates) || updates.length === 0) {
+                    throw new Error('缺少参数: updates（需要非空数组）');
+                }
+                const filePath = path.join(PROJECT_ROOT, 'json', `${configFile}.data`);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`配置文件不存在: ${configFile}`);
+                }
+                const { data, rawContent } = readConfigFile(filePath);
+                const results = [];
+                const modifications = [];
+                for (const update of updates) {
+                    if (!update.field_path || !update.value) {
+                        results.push(`跳过无效项: ${JSON.stringify(update)}`);
+                        continue;
+                    }
+                    const argb = hexToARGB(update.value);
+                    if (!argb) {
+                        results.push(`跳过 ${update.field_path}: 无效颜色格式 ${update.value}`);
+                        continue;
+                    }
+                    const decValue = argbToDec(argb);
+                    const oldValue = getFieldValue(data, update.field_path);
+                    modifications.push({ path: update.field_path, value: decValue });
+                    results.push(`${update.field_path}: ${oldValue} -> ${decValue} (${update.value})`);
+                }
+                // 使用保留注释的方式保存
+                if (modifications.length > 0) {
+                    saveConfigFileWithComments(filePath, rawContent, modifications);
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `批量更新完成 (${modifications.length}/${updates.length} 成功):\n${results.join('\n')}`,
+                        },
+                    ],
+                };
+            }
+            case 'convert_color': {
+                const value = args?.value;
+                if (typeof value === 'number') {
+                    // 十进制转十六进制
+                    const argb = decToARGB(value);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    decimal: value,
+                                    hex: argbToHex(argb),
+                                    hexNoAlpha: argbToHex(argb, false),
+                                    argb: argb,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                else if (typeof value === 'string') {
+                    // 十六进制转十进制
+                    const argb = hexToARGB(value);
+                    if (!argb) {
+                        throw new Error(`无效的颜色格式: ${value}`);
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    hex: value,
+                                    decimal: argbToDec(argb),
+                                    argb: argb,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                throw new Error('请提供数字或十六进制字符串');
+            }
+            default:
+                throw new Error(`未知工具: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `错误: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ============= 资源定义（可选，用于直接读取配置文件） =============
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const files = listConfigFiles(PROJECT_ROOT);
+    return {
+        resources: files.map((file) => ({
+            uri: `lanestyle://config/${file.name}`,
+            name: file.name,
+            description: file.description,
+            mimeType: 'application/json',
+        })),
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const match = uri.match(/^lanestyle:\/\/config\/(.+)$/);
+    if (!match) {
+        throw new Error(`无效的资源 URI: ${uri}`);
+    }
+    const configName = match[1];
+    const filePath = path.join(PROJECT_ROOT, 'json', `${configName}.data`);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`配置文件不存在: ${configName}`);
+    }
+    const { data } = readConfigFile(filePath);
+    return {
+        contents: [
+            {
+                uri,
+                mimeType: 'application/json',
+                text: JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+});
+// ============= 启动服务器 =============
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('LaneStyle MCP Server 已启动');
+    console.error(`项目目录: ${PROJECT_ROOT}`);
+}
+main().catch((error) => {
+    console.error('启动失败:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "lanestyle-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for LaneStyle Editor - AI-powered lane style configuration",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "lanestyle-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "lanestyle",
+    "ai",
+    "lane-editor",
+    "style-config"
+  ],
+  "author": "qiquan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/lanestyle-mcp-server"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}