@atlisp/mcp 1.8.19 → 1.8.21

package/dist/cad-worker.js

@@ -496,8 +496,6 @@ async function waitForIdle(platform) {
   return false;
 }
 
-export { checkParens } from './lisp-security.js';
-
 async function connectToPlatform(targetPlatform) {
   return new Promise((resolve, reject) => {
     cadConnectByName(targetPlatform, (e, r) => {
@@ -581,9 +579,12 @@ async function handleMessage(msg) {
     if (!parenCheck.valid) {
       return { success: false, error: `括号错误: ${parenCheck.error} (位置 ${parenCheck.pos})` };
     }
-    const injectionCheck = validateLispCodeWorker(msg.code);
-    if (!injectionCheck.valid) {
-      return { success: false, error: `安全限制: ${injectionCheck.error}` };
+    const securityLevel = process.env.SECURITY_LEVEL || 'strict';
+    if (securityLevel !== 'relaxed') {
+      const injectionCheck = validateLispCodeWorker(msg.code);
+      if (!injectionCheck.valid) {
+        return { success: false, error: `安全限制: ${injectionCheck.error}` };
+      }
     }
     if (msg.code.length > 255) {
       const cacheEnabled = process.env.LONG_CODE_CACHE === '1';

package/dist/config.js

@@ -34,6 +34,11 @@ const envSchema = z.object({
     LLM_MAX_TOKENS: z.string().optional().default('4096'),
     LLM_TEMPERATURE: z.string().optional().default('0.7'),
     WORKER_POOL_SIZE: z.string().optional().default('2'),
+    LINT_PRESET: z.string().optional().default(''),
+    LINT_CONFIG_PATH: z.string().optional().default(''),
+    LINT_LEVEL: z.string().optional().default(''),
+    NO_LINT: z.string().optional().default(''),
+    SECURITY_LEVEL: z.string().optional().default('strict'),
 });
 
 const configSchema = z.object({
@@ -73,6 +78,11 @@ const configSchema = z.object({
     llmTemperature: z.number().optional(),
     maxPoolSize: z.number().optional(),
     workerPoolSize: z.number().optional(),
+    lintPreset: z.string().optional(),
+    lintConfigPath: z.string().optional(),
+    lintLevel: z.string().optional(),
+    noLint: z.boolean().optional(),
+    securityLevel: z.enum(['strict', 'standard', 'relaxed']).optional(),
 });
 
 function parseArgs() {
@@ -103,6 +113,20 @@ function parseArgs() {
             i++;
         } else if (args[i] === '--debug') {
             result.debug = true;
+        } else if (args[i] === '--lint-preset' && args[i + 1]) {
+            result.lintPreset = args[i + 1];
+            i++;
+        } else if (args[i] === '--lint-config' && args[i + 1]) {
+            result.lintConfigPath = args[i + 1];
+            i++;
+        } else if (args[i] === '--lint-level' && args[i + 1]) {
+            result.lintLevel = args[i + 1];
+            i++;
+        } else if (args[i] === '--no-lint' || args[i] === '--lint-off') {
+            result.noLint = true;
+        } else if (args[i] === '--security-level' && args[i + 1]) {
+            result.securityLevel = args[i + 1];
+            i++;
         }
     }
     return result;
@@ -174,8 +198,18 @@ const config = {
     llmTemperature: fileConfig?.llmTemperature || parseFloat(env.LLM_TEMPERATURE),
     maxPoolSize: fileConfig?.maxPoolSize || 3,
     workerPoolSize: fileConfig?.workerPoolSize || parseInt(env.WORKER_POOL_SIZE, 10),
+    lintPreset: fileConfig?.lintPreset || cliArgs.lintPreset || env.LINT_PRESET || undefined,
+    lintConfigPath: fileConfig?.lintConfigPath || cliArgs.lintConfigPath || env.LINT_CONFIG_PATH || undefined,
+    lintLevel: fileConfig?.lintLevel || cliArgs.lintLevel || env.LINT_LEVEL || undefined,
+    noLint: fileConfig?.noLint ?? cliArgs.noLint ?? (env.NO_LINT === 'true'),
+    securityLevel: fileConfig?.securityLevel ?? cliArgs.securityLevel ?? (env.SECURITY_LEVEL || 'strict'),
 };
 
+if (config.lintConfigPath) process.env.LINT_CONFIG_PATH = config.lintConfigPath;
+if (config.lintPreset) process.env.LINT_PRESET = config.lintPreset;
+if (config.lintLevel) process.env.LINT_LEVEL = config.lintLevel;
+if (config.noLint) process.env.NO_LINT = 'true';
+
 export function validateConfig() {
     const errors = [];
     if (config.transport === 'http' || config.transport === 'ws') {

package/dist/handlers/cad-handlers.js

@@ -1,6 +1,7 @@
 import { cad } from '../cad.js';
 import { log } from '../logger.js';
 import { withCadConnection, mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
+import { analyzeLispCode } from '../lint-analyzer.js';
 
 export async function connectCad(platform = null) {
     log(`connect_cad called${platform ? ` (target: ${platform})` : ''}, cad.connected before: ${cad.connected}`);
@@ -23,6 +24,13 @@ export async function connectCad(platform = null) {
 export const evalLisp = withCadConnection(async (code, withResult = false, encoding = null) => {
     const trimmed = (code || '').trim();
     if (!trimmed) return mcpSuccess('命令为空，未发送');
+
+    const analysis = analyzeLispCode(trimmed);
+    if (!analysis.valid) {
+        const detail = analysis.errors.map(e => `  L${e.line}: [${e.rule}] ${e.message}`).join('\n');
+        return mcpError(`代码存在安全问题:\n${detail}`);
+    }
+
     if (withResult) {
         const result = await cad.sendCommandWithResult(trimmed, encoding);
         if (result !== null) {
@@ -42,6 +50,13 @@ export const getCadInfo = withCadConnection(async () => {
 export const atCommand = withCadConnection(async (command) => {
     const trimmed = (command || '').trim();
     if (!trimmed) return mcpSuccess('命令为空，未发送');
+
+    const analysis = analyzeLispCode(trimmed);
+    if (!analysis.valid) {
+        const detail = analysis.errors.map(e => `  L${e.line}: [${e.rule}] ${e.message}`).join('\n');
+        return mcpError(`代码存在安全问题:\n${detail}`);
+    }
+
     await cad.sendCommand(trimmed + '\n');
     return mcpSuccess('已发送命令');
 });

package/dist/handlers/draw-handlers.js

@@ -85,3 +85,44 @@ export const drawHatch = withCadConnection(async (points, pattern) => {
     await cad.sendCommand(`(command "_.HATCH" "${escapeLispString(pat)}" "" "")`);
     return mcpSuccess(`已创建图案填充: ${pat}`);
 });
+
+export const drawHelix = withCadConnection(async (center, topRadius, bottomRadius, height, turns = 3) => {
+    await cad.sendCommand(`(command "_.HELIX" "${escapeLispString(center)}" ${bottomRadius} ${topRadius} ${height} ${turns})`);
+    return mcpSuccess(`已创建螺旋: 中心 ${center}，半径 ${bottomRadius}→${topRadius}，高度 ${height}，${turns} 圈`);
+});
+
+export const drawDonut = withCadConnection(async (center, innerRadius, outerRadius) => {
+    await cad.sendCommand(`(command "_.DONUT" ${innerRadius} ${outerRadius} "${escapeLispString(center)}" "")`);
+    return mcpSuccess(`已绘制圆环: 中心 ${center}，内径 ${innerRadius}，外径 ${outerRadius}`);
+});
+
+export const draw2dSolid = withCadConnection(async (p1, p2, p3, p4) => {
+    await cad.sendCommand(`(command "_.SOLID" "${escapeLispString(p1)}" "${escapeLispString(p2)}" "${escapeLispString(p3)}" "${escapeLispString(p4)}" "")`);
+    return mcpSuccess(`已创建 2D 实体: ${p1} ${p2} ${p3} ${p4}`);
+});
+
+export const drawXline = withCadConnection(async (point, direction) => {
+    await cad.sendCommand(`(command "_.XLINE" "${escapeLispString(point)}" "${escapeLispString(direction)}")`);
+    return mcpSuccess(`已创建构造线: 经过 ${point}，方向 ${direction}`);
+});
+
+export const drawRay = withCadConnection(async (point, direction) => {
+    await cad.sendCommand(`(command "_.RAY" "${escapeLispString(point)}" "${escapeLispString(direction)}")`);
+    return mcpSuccess(`已创建射线: 起点 ${point}，方向 ${direction}`);
+});
+
+export const drawLeader = withCadConnection(async (points, annotation) => {
+    const pts = points.split(/\s+/).filter(Boolean);
+    const cmds = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
+    if (annotation) {
+        await cad.sendCommand(`(command "_.LEADER" ${cmds} "" "${escapeLispString(annotation)}" "")`);
+    } else {
+        await cad.sendCommand(`(command "_.LEADER" ${cmds} "" "" "")`);
+    }
+    return mcpSuccess(`已创建引线标注: ${points}`);
+});
+
+export const drawTable = withCadConnection(async (insertionPoint, rows, columns, rowHeight = 10, colWidth = 20) => {
+    await cad.sendCommand(`(command "_.TABLE" "${escapeLispString(insertionPoint)}" ${columns} ${rows} ${rowHeight} ${colWidth})`);
+    return mcpSuccess(`已创建表格: ${insertionPoint}，${rows}×${columns}`);
+});

package/dist/handlers/lint-handlers.js

@@ -0,0 +1,64 @@
+import { analyzeLispCode } from '../lint-analyzer.js';
+import { formatCode } from '@atlisp/lint/dist/formatter.js';
+import { lintProject } from '@atlisp/lint/dist/project.js';
+import { RULES } from '@atlisp/lint/dist/rules.js';
+import { loadConfig } from '@atlisp/lint/dist/config.js';
+
+function getConfig(input) {
+  const base = loadConfig();
+  if (input?.checks) Object.assign(base.checks, input.checks);
+  if (input?.dangerous_calls) Object.assign(base.dangerous_calls, input.dangerous_calls);
+  return base;
+}
+
+export async function analyzeLispCodeHandler(args) {
+  const { code, config } = args || {};
+  if (!code || !code.trim()) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ valid: true, issues: [], summary: '代码为空，无需分析' }) }],
+    };
+  }
+  const result = analyzeLispCode(code, { lintConfig: config });
+  return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+}
+
+export async function formatLispCodeHandler(args) {
+  const { code, tabWidth } = args || {};
+  if (!code) {
+    return { content: [{ type: 'text', text: '需要 code 参数' }], isError: true };
+  }
+  try {
+    const formatted = formatCode(code, { tabWidth: tabWidth || 2 });
+    return { content: [{ type: 'text', text: formatted }] };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `格式化失败: ${e.message}` }], isError: true };
+  }
+}
+
+export async function listLintRulesHandler() {
+  try {
+    const list = RULES.map(r => ({
+      rule: r.name,
+      severity: r.severity || 'warn',
+      description: r.description || '',
+      fixable: !!r.fix,
+    }));
+    return { content: [{ type: 'text', text: JSON.stringify(list, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `获取规则列表失败: ${e.message}` }], isError: true };
+  }
+}
+
+export async function lintProjectHandler(args) {
+  const { directory, config: configInput } = args || {};
+  if (!directory) {
+    return { content: [{ type: 'text', text: '需要 directory 参数' }], isError: true };
+  }
+  try {
+    const lintConfig = getConfig(configInput);
+    const results = await lintProject(directory, lintConfig);
+    return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `项目分析失败: ${e.message}` }], isError: true };
+  }
+}

package/dist/handlers/resource-defs.js

@@ -20,6 +20,8 @@ export const RESOURCES = [
   { uri: 'atlisp://platforms', name: 'Platforms', description: '支持的平台信息', mimeType: 'application/json', subscribable: false },
   { uri: 'atlisp://standards/drafting', name: 'Drafting Standards', description: 'CAD 制图规范', mimeType: 'application/json', subscribable: false },
   { uri: 'atlisp://standards/coding', name: 'Coding Standards', description: '@lisp 编码规范', mimeType: 'application/json', subscribable: false },
+  { uri: 'atlisp://dwg/context', name: 'DWG Context', description: '当前图纸上下文摘要。返回文档名/路径/布局/UCS/图层列表/实体统计/系统变量组合信息，帮助快速了解当前 CAD 状态', mimeType: 'application/json', subscribable: true },
+  { uri: 'atlisp://tools/relationships', name: 'Tool Relationships', description: '工具依赖关系图。描述工具间的调用链关系（如 select_entities → batch_delete），帮助理解工具组合使用方式', mimeType: 'application/json', subscribable: false },
 ];
 
 export const TBL_INFO = {

package/dist/handlers/resource-handlers.js

@@ -1047,6 +1047,90 @@ async function getCadEvents(params) {
  * Fetches a lightweight snapshot of current CAD state.
  * Returns a flat object with entity count, layer names, DWG info, etc.
  */
+async function getDwgContext() {
+  const snapshot = await getCadSnapshot();
+  if (!snapshot || !snapshot.cadConnected) {
+    return { connected: false, message: 'CAD 未连接' };
+  }
+  try {
+    const code = `(progn
+  (vl-load-com)
+  (setq ctx nil)
+  (setq ctx (cons (cons "layout" (getvar "ctab")) ctx))
+  (setq ctx (cons (cons "ucs" (getvar "ucsname")) ctx))
+  (setq ctx (cons (cons "insunits" (getvar "insunits")) ctx))
+  (setq ctx (cons (cons "ltscale" (getvar "ltscale")) ctx))
+  (setq ctx (cons (cons "limmin" (vl-princ-to-string (getvar "limmin"))) ctx))
+  (setq ctx (cons (cons "limmax" (vl-princ-to-string (getvar "limmax"))) ctx))
+  (setq ctx (cons (cons "extmin" (vl-princ-to-string (getvar "extmin"))) ctx))
+  (setq ctx (cons (cons "extmax" (vl-princ-to-string (getvar "extmax"))) ctx))
+  (vl-prin1-to-string ctx))`;
+    const resultStr = await cad.sendCommandWithResult(code);
+    const parsed = parseLispRecursive(resultStr);
+    return {
+      connected: true,
+      docName: snapshot.dwgName,
+      docPath: snapshot.dwgPath,
+      platform: snapshot.platform,
+      entityCount: snapshot.entityCount,
+      layerCount: snapshot.layerCount,
+      layerNames: snapshot.layerNames,
+      extra: parsed && Array.isArray(parsed) ? Object.fromEntries(parsed) : {},
+    };
+  } catch {
+    return {
+      connected: true,
+      docName: snapshot.dwgName,
+      docPath: snapshot.dwgPath,
+      platform: snapshot.platform,
+      entityCount: snapshot.entityCount,
+      layerCount: snapshot.layerCount,
+      layerNames: snapshot.layerNames,
+    };
+  }
+}
+
+function getToolRelationships() {
+  return {
+    selection: {
+      tools: ['select_entities', 'select_all', 'select_last', 'select_by_color', 'find_entities_in_window', 'find_entities_near_point'],
+      next: ['batch_delete', 'batch_move', 'batch_copy', 'batch_set_layer', 'batch_set_color', 'batch_set_linetype', 'batch_rotate', 'batch_scale', 'batch_mirror', 'batch_explode', 'batch_match_properties'],
+    },
+    drawing: {
+      tools: ['draw_line', 'draw_circle', 'draw_arc', 'draw_rectangle', 'draw_polygon', 'draw_polyline', 'draw_spline', 'draw_text', 'draw_mtext', 'draw_ellipse'],
+      next: ['get_entity', 'set_entity', 'batch_match_properties', 'copy_entity', 'move_entity', 'rotate_entity', 'scale_entity'],
+    },
+    editing: {
+      tools: ['trim_entity', 'extend_entity', 'fillet', 'chamfer', 'break_entity', 'join_entities', 'stretch', 'offset_entity', 'mirror_entity'],
+      next: ['get_entity', 'set_entity'],
+    },
+    batch_ops: {
+      tools: ['batch_copy', 'batch_move', 'batch_delete', 'batch_set_layer', 'batch_set_color', 'batch_explode', 'batch_rotate', 'batch_scale'],
+      previous: ['select_entities', 'select_all'],
+      next: ['save_dwg'],
+    },
+    export: {
+      tools: ['export_pdf', 'export_dxf', 'export_dwf', 'export_svg', 'export_stl', 'export_bmp'],
+      previous: ['open_dwg', 'new_document', 'save_dwg'],
+      next: [],
+    },
+    layers: {
+      tools: ['create_layer', 'set_layer', 'layer_isolate', 'layer_freeze_all', 'layer_thaw_all', 'layer_lock_all', 'layer_unlock_all', 'layer_merge'],
+      next: ['set_current_layer', 'batch_set_layer'],
+    },
+    blocks: {
+      tools: ['get_blocks', 'insert_block', 'explode_block', 'get_block_attributes', 'set_block_attribute', 'get_dynamic_block_properties'],
+      previous: ['select_entities'],
+      next: ['save_dwg'],
+    },
+    analysis: {
+      tools: ['analyze_lisp_code', 'stream_entities', 'stream_text', 'stream_block_refs', 'get_entity_info', 'get_bounding_box', 'measure_distance', 'measure_area'],
+      previous: [],
+      next: [],
+    },
+  };
+}
+
 async function getCadSnapshot() {
   const cached = getCached('cad:snapshot');
   if (cached) return cached;
@@ -1198,45 +1282,26 @@ export async function listResources(subscribedUris = []) {
     };
 
     if (hasLive) {
-      // Enrich resource descriptors with live CAD state
       switch (r.uri) {
         case 'atlisp://cad/info':
           entry.description = `CAD 连接信息 (${snapshot.platform || '未知平台'}${snapshot.dwgName ? ', ' + snapshot.dwgName : ''})`;
-          entry.annotations = {
-            platform: snapshot.platform,
-            dwgName: snapshot.dwgName,
-            cadConnected: true,
-          };
           break;
-
         case 'atlisp://dwg/entities':
           entry.description = `图元列表。${snapshot.entityCount} 个实体，${snapshot.layerCount} 个图层。支持 ?type=LINE&layer=0&bbox=0,0,100,100`;
-          entry.size = snapshot.entityCount;
-          entry.annotations = {
-            entityCount: snapshot.entityCount,
-            layerCount: snapshot.layerCount,
-          };
           break;
-
         case 'atlisp://dwg/name':
           entry.description = `当前 DWG 文件名: ${snapshot.dwgName || '(未命名)'}`;
-          entry.annotations = { name: snapshot.dwgName };
           break;
-
         case 'atlisp://dwg/path':
-          entry.description = snapshot.dwgPath
-            ? `文件完整路径: ${snapshot.dwgPath}`
-            : '文件完整路径';
-          entry.annotations = { path: snapshot.dwgPath };
+          entry.description = snapshot.dwgPath ? `文件完整路径: ${snapshot.dwgPath}` : '文件完整路径';
           break;
-
         case 'atlisp://dwg/tbl':
           entry.description = `CAD 表数据 (${snapshot.layerCount} 个图层)。支持路径方式 atlisp://dwg/tbl/layer`;
-          entry.annotations = { layerCount: snapshot.layerCount };
           break;
-
-        default:
+        case 'atlisp://dwg/context':
+          entry.description = `当前图纸上下文: ${snapshot.dwgName || '(未命名)'}，${snapshot.entityCount} 实体，${snapshot.layerCount} 图层`;
           break;
+        default: break;
       }
     }
 
@@ -1316,6 +1381,10 @@ export async function readResource(uri) {
       return getCodingStandards();
     case 'atlisp://cad/events':
       return await getCadEvents(params);
+    case 'atlisp://dwg/context':
+      return await getDwgContext();
+    case 'atlisp://tools/relationships':
+      return getToolRelationships();
     default:
       throw new Error(`资源不存在: ${uri}`);
   }

package/dist/lisp-security.js

@@ -1,53 +1,90 @@
 import { log, error as logError } from './logger.js';
+import config, { onConfigChange } from './config.js';
 
 export const THREAT_BLOCK = 'block';
 export const THREAT_WARN = 'warn';
 export const THREAT_ALLOW = 'allow';
 
+export const SECURITY_LEVELS = ['strict', 'standard', 'relaxed'];
+
+const CVT = {
+  strict: THREAT_BLOCK,
+  standard: THREAT_WARN,
+  relaxed: THREAT_ALLOW,
+};
+
+function getLevel() {
+  const level = config?.securityLevel || 'strict';
+  return CVT[level] || THREAT_BLOCK;
+}
+
 export const SECURITY_RULES = [
-  { re: /\beval\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止使用 eval 函数' },
-  { re: /\bstartapp\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止使用 startapp 函数' },
-  { re: /\bvl-bt\b/i, severity: THREAT_BLOCK, msg: '禁止使用 vl-bt 函数' },
-  { re: /\bvl-exit-with-value\b/i, severity: THREAT_BLOCK, msg: '禁止使用 vl-exit-with-value' },
-  { re: /\bvl-exit-with-error\b/i, severity: THREAT_BLOCK, msg: '禁止使用 vl-exit-with-error' },
-  { re: /\bvlax-import-type-library\b/i, severity: THREAT_BLOCK, msg: '禁止导入类型库' },
-  { re: /\bvlax-add-cmd\b/i, severity: THREAT_BLOCK, msg: '禁止注册新命令' },
-  { re: /\bvla-Delete\b/i, severity: THREAT_BLOCK, msg: '禁止直接删除 vla 对象' },
-  { re: /\bvla-Save\b/i, severity: THREAT_BLOCK, msg: '禁止直接保存文档' },
-  { re: /\bdirectory\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止使用 directory 函数' },
-  { re: /\bvla-deletefile\b/i, severity: THREAT_BLOCK, msg: '禁止删除文件' },
-  { re: /\bvla-copyfile\b/i, severity: THREAT_BLOCK, msg: '禁止复制文件' },
-  { re: /\bvla-movefile\b/i, severity: THREAT_BLOCK, msg: '禁止移动文件' },
-  { re: /\bvl-file-copy\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止文件复制' },
-  { re: /\bvl-file-delete\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止文件删除' },
-  { re: /\bvl-file-rename\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止文件重命名' },
-  { re: /\bdos_command_string\s*[(\s]/i, severity: THREAT_BLOCK, msg: '禁止使用 dos_command_string' },
-  { re: /\bload\s*[(\s"]/i, severity: THREAT_WARN, msg: 'load 函数可能加载外部代码' },
-  { re: /\bcommand\s*["\s]*[_(]?\s*["']?\.?\s*_?(?:quit|exit|close|open|new|recover|audit|purge|wblock|export)/i, severity: THREAT_BLOCK, msg: '禁止使用危险 CAD 命令' },
-  { re: /\b(?:read-line|read-char|write-line|write-char)\s*[(\s]/i, severity: THREAT_WARN, msg: '文件 I/O 操作可能影响系统' },
-  { re: /\bvla-add\b/i, severity: THREAT_ALLOW, msg: 'vla-add 创建新对象' },
+  { re: /\bstartapp\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 startapp 函数' },
+  { re: /\bvl-bt\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 vl-bt 函数' },
+  { re: /\bvlax-import-type-library\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止导入类型库' },
+  { re: /\bdos_command_string\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 dos_command_string' },
+  { re: /\beval\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 eval 函数' },
+  { re: /\bcommand\s*["\s]*[_(]?\s*["']?\.?\s*_?(?:shell|quit|exit|close|open|new|recover|audit|purge|wblock|export)/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用危险 CAD 命令' },
+  { re: /\bload\s*[(\s"]/i, baseSeverity: THREAT_BLOCK, msg: 'load 函数可能加载外部代码' },
+  { re: /\b(?:read-line|read-char|write-line|write-char)\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '文件 I/O 操作可能影响系统' },
+  { re: /\bvl-file-copy\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止文件复制' },
+  { re: /\bvl-file-delete\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止文件删除' },
+  { re: /\bvl-file-rename\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止文件重命名' },
+  { re: /\bvl-registry-write[\s\)]/i, baseSeverity: THREAT_BLOCK, msg: 'vl-registry-write 会修改注册表' },
+  { re: /\bvl-exit-with-value\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 vl-exit-with-value' },
+  { re: /\bvl-exit-with-error\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 vl-exit-with-error' },
+  { re: /\bvlax-add-cmd\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止注册新命令' },
+  { re: /\bvla-Delete\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止直接删除 vla 对象' },
+  { re: /\bvla-Save\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止直接保存文档' },
+  { re: /\bdirectory\s*[(\s]/i, baseSeverity: THREAT_BLOCK, msg: '禁止使用 directory 函数' },
+  { re: /\bvla-deletefile\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止删除文件' },
+  { re: /\bvla-copyfile\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止复制文件' },
+  { re: /\bvla-movefile\b/i, baseSeverity: THREAT_BLOCK, msg: '禁止移动文件' },
 ];
 
-export function stripStringsAndComments(code) {
-  const withoutStrings = code.replace(/"([^"\\]*(?:\\.[^"\\]*)*)"/g, '');
-  return withoutStrings.replace(/;.*$/gm, '');
+let _cachedLevel = null;
+
+export function refreshConfig() {
+  _cachedLevel = null;
+}
+
+try {
+  onConfigChange(() => { _cachedLevel = null; });
+} catch (_) {}
+
+function resolveSeverity(rule) {
+  if (_cachedLevel) return _cachedLevel;
+  _cachedLevel = getLevel();
+  return _cachedLevel;
 }
 
 export function validateLispCodeWorker(code) {
   const clean = stripStringsAndComments(code);
-  for (const { re, severity, msg } of SECURITY_RULES) {
+  const effectiveSeverity = resolveSeverity();
+
+  for (const rule of SECURITY_RULES) {
+    const re = rule.re;
     if (re.test(clean)) {
-      if (severity === THREAT_BLOCK) {
-        return { valid: false, error: msg };
+      if (effectiveSeverity === THREAT_BLOCK) {
+        return { valid: false, error: rule.msg };
       }
-      if (severity === THREAT_WARN) {
-        log('WARN: ' + msg);
+      if (effectiveSeverity === THREAT_WARN) {
+        log('WARN: ' + rule.msg);
       }
     }
   }
   return { valid: true };
 }
 
+export function getEffectiveSeverity() {
+  return resolveSeverity();
+}
+
+export function stripStringsAndComments(code) {
+  const withoutStrings = code.replace(/"([^"\\]*(?:\\.[^"\\]*)*)"/g, '');
+  return withoutStrings.replace(/;.*$/gm, '');
+}
+
 export function checkParens(code) {
   let depth = 0;
   let inString = false;

package/dist/pipelines/analyze-and-report.json

@@ -0,0 +1,16 @@
+{
+  "name": "analyze-and-report",
+  "description": "分析当前图纸实体并生成统计报告。先获取所有实体，再逐个获取详细信息",
+  "steps": [
+    {
+      "name": "entities",
+      "tool": "stream_entities",
+      "args": { "chunk": 500, "offset": 0 }
+    },
+    {
+      "name": "info",
+      "tool": "get_cad_info",
+      "args": {}
+    }
+  ]
+}

package/dist/pipelines/batch-export-pdfs.json

@@ -0,0 +1,11 @@
+{
+  "name": "batch-export-pdfs",
+  "description": "遍历所有布局并逐个导出为 PDF。先列出布局，再对每个布局执行导出",
+  "steps": [
+    {
+      "name": "layouts",
+      "tool": "list_layouts",
+      "args": {}
+    }
+  ]
+}

package/dist/pipelines/batch-layer-move.json

@@ -0,0 +1,19 @@
+{
+  "name": "batch-layer-move",
+  "description": "按条件选择实体并移动到目标图层。先选择指定类型/图层的实体，再移动到新图层",
+  "steps": [
+    {
+      "name": "selection",
+      "tool": "select_entities",
+      "args": { "filter": { "type": "LINE", "layer": "0" } }
+    },
+    {
+      "name": "move",
+      "tool": "batch_set_layer",
+      "args": {
+        "handles": "$ref:selection.result",
+        "layerName": "TargetLayer"
+      }
+    }
+  ]
+}

package/dist/pipelines/export-current-drawing.json

@@ -0,0 +1,18 @@
+{
+  "name": "export-current-drawing",
+  "description": "导出当前图纸为 PDF。先获取图纸信息，再执行导出",
+  "steps": [
+    {
+      "name": "info",
+      "tool": "get_cad_info",
+      "args": {}
+    },
+    {
+      "name": "export",
+      "tool": "export_pdf",
+      "args": {
+        "outputPath": "$ref:info.docName.pdf"
+      }
+    }
+  ]
+}

package/dist/pipelines/purge-and-save.json

@@ -0,0 +1,16 @@
+{
+  "name": "purge-and-save",
+  "description": "清理未使用的块、图层、样式，然后保存当前图形",
+  "steps": [
+    {
+      "name": "purge_blocks",
+      "tool": "purge_all",
+      "args": {}
+    },
+    {
+      "name": "save",
+      "tool": "save_dwg",
+      "args": {}
+    }
+  ]
+}

package/dist/prompts/definitions/analyze-drawing.json

@@ -0,0 +1,6 @@
+{
+  "name": "analyze-drawing",
+  "description": "分析当前图纸统计信息",
+  "arguments": [],
+  "handlerFile": "analyze-drawing"
+}

package/dist/prompts/definitions/batch-draw-lines.json

@@ -0,0 +1,14 @@
+{
+  "name": "batch-draw-lines",
+  "description": "批量绘制线段",
+  "arguments": [
+    { "name": "count", "description": "线段数量", "required": true, "default": 5 },
+    { "name": "length", "description": "线段长度", "required": false, "default": 1000 }
+  ],
+  "templates": {
+    "default": {
+      "code": "(defun c:batch-lines (/ i)\n  (setq i 0)\n  (repeat {{count}}\n    (command \"_.line\" (list (* i {{length}}) 0) (list (* (1+ i) {{length}}) 0) \"\")\n    (setq i (1+ i))\n  )\n  (princ)\n)\n(c:batch-lines)",
+      "description": "批量绘制 {{count}} 条长度为 {{length}} 的水平线段：\n\n此代码将绘制 {{count}} 条首尾相连的水平线段。"
+    }
+  }
+}

package/dist/prompts/definitions/coding-conventions.json

@@ -0,0 +1,11 @@
+{
+  "name": "coding-conventions",
+  "description": "AutoLISP 编码规范",
+  "arguments": [],
+  "templates": {
+    "default": {
+      "code": "",
+      "description": "## AutoLISP 编码规范\n\n### 禁止作为变量名的内置函数\n\n以下 AutoLISP 内置函数不可用作变量名，否则会覆盖内置函数导致程序错误：\n\n| 变量名 | 内置函数 | 说明 |\n|--------|----------|------|\n| `angle` | `(angle pt1 pt2)` | 严禁使用！获取两点连线与X轴夹角 |\n| `length` | `(length list)` | 获取列表长度 |\n| `type` | `(type symbol)` | 获取数据类型 |\n| `assoc` | `(assoc key alist)` | 关联表查找 |\n| `member` | `(member item list)` | 成员检测 |\n| `subst` | `(subst new old list)` | 替换列表元素 |\n| `append` | `(append list ...)` | 合并列表 |\n| `reverse` | `(reverse list)` | 反转列表 |\n| `apply` | `(apply fn list)` | 应用函数 |\n| `mapcar` | `(mapcar fn list...)` | 映射函数 |\n\n### 正确做法\n\n```lisp\n;; 错误：覆盖了内置 angle 函数\n(setq angle 45)\n\n;; 正确：使用有意义的变量名\n(setq rot-angle 45)\n(setq rotation 45)\n(setq ang 45)\n```"
+    }
+  }
+}