@atlisp/mcp 1.8.16 → 1.8.18

package/dist/handlers/cad-handlers.js

@@ -0,0 +1,180 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { escapeLispString } from '../handler-utils.js';
+
+export async function connectCad(platform = null) {
+    log(`connect_cad called${platform ? ` (target: ${platform})` : ''}, cad.connected before: ${cad.connected}`);
+    try {
+        log('calling cad.connect()...');
+        const connected = await cad.connect(platform);
+        log('cad.connect() returned: ' + connected + ', cad.connected: ' + cad.connected);
+        if (connected) {
+            const messages = [`已连接到 ${cad.getPlatform()} ${cad.getVersion()}`];
+            initAtlisp().catch(e => log(`connect_cad: initAtlisp failed: ${e.message}`));
+            return { content: [{ type: 'text', text: messages.join('；') }] };
+        }
+        return { content: [{ type: 'text', text: '未能连接或启动 CAD，请确保 CAD 已安装' }], isError: true };
+    } catch (e) {
+        log('connect_cad error: ' + e.message);
+        return { content: [{ type: 'text', text: `连接 CAD 失败: ${e.message}` }], isError: true };
+    }
+}
+
+export async function evalLisp(code, withResult = false, encoding = null) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) {
+        return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    }
+    const trimmed = (code || '').trim();
+    if (!trimmed) return { content: [{ type: 'text', text: '命令为空，未发送' }] };
+    try {
+        if (withResult) {
+            const result = await cad.sendCommandWithResult(trimmed, encoding);
+            if (result !== null) {
+                return { content: [{ type: 'text', text: result }] };
+            }
+            return { content: [{ type: 'text', text: '执行失败或无返回值' }], isError: true };
+        } else {
+            await cad.sendCommand(trimmed + '\n');
+            return { content: [{ type: 'text', text: `已发送命令` }] };
+        }
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getCadInfo() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: 'CAD 未连接' }] };
+    const info = await cad.getInfo();
+    return { content: [{ type: 'text', text: info }] };
+}
+
+export async function atCommand(command) {
+    if (!cad.connected) return { content: [{ type: 'text', text: '请先连接 CAD' }], isError: true };
+    const trimmed = (command || '').trim();
+    if (!trimmed) return { content: [{ type: 'text', text: '命令为空，未发送' }] };
+    await cad.sendCommand(trimmed + '\n');
+    return { content: [{ type: 'text', text: '已发送命令' }] };
+}
+
+export async function newDocument() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const result = await cad.newDoc();
+    if (result) {
+        return { content: [{ type: 'text', text: '已在 CAD 中新建空白文档' }] };
+    }
+    return { content: [{ type: 'text', text: '新建文档失败' }], isError: true };
+}
+
+export async function bringToFront() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const result = await cad.bringToFront();
+    if (result) {
+        return { content: [{ type: 'text', text: '已将 CAD 窗口切换到前台' }] };
+    }
+    return { content: [{ type: 'text', text: '切换前台失败' }], isError: true };
+}
+
+export async function installAtlisp() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const installCode = '(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o\'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o\'send)(v o\'WaitforResponse 1000)(e(r(vlax-get-property o\'ResponseText))))';
+    await cad.sendCommand(installCode + '\n');
+    return { content: [{ type: 'text', text: '已发送 @lisp 安装代码到 CAD' }] };
+}
+
+export async function listFunctionsInCad() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const result = await cad.sendCommandWithResult('(atoms-family 0)', null);
+        if (result) return { content: [{ type: 'text', text: result }] };
+        return { content: [{ type: 'text', text: 'CAD 函数列表为空' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getSystemStatus() {
+  const status = {
+    mcp: { version: process.env.npm_package_version || 'unknown' },
+    worker: { alive: false },
+    cad: { connected: false, platform: null, version: null, busy: false, hasDoc: false },
+    lisp: { available: false, testResult: null, error: null },
+    packages: null,
+  };
+
+  try {
+    status.worker.alive = await cad.ping();
+  } catch { status.worker.alive = false; }
+
+  status.cad.connected = cad.connected;
+  if (cad.connected) {
+    status.cad.platform = cad.getPlatform();
+    status.cad.version = cad.getVersion();
+    try { status.cad.busy = await cad.isBusy(); } catch (e) { log(`cad-handlers: isBusy error: ${e.message}`); }
+    try {
+      const doc = await cad.hasDoc();
+      status.cad.hasDoc = doc.hasDoc;
+    } catch (e) { log(`cad-handlers: hasDoc error: ${e.message}`); }
+    try {
+      const r = await cad.sendCommandWithResult('(+ 1 2)');
+      if (r !== null && r !== undefined) {
+        status.lisp.available = true;
+        status.lisp.testResult = String(r).trim();
+      }
+    } catch (e) {
+      status.lisp.error = e.message;
+    }
+    try {
+      const pkgResult = await cad.sendCommandWithResult('(@::package-list-in-local)');
+      if (pkgResult && pkgResult !== 'nil') {
+        status.packages = pkgResult;
+      }
+    } catch (e) { log(`cad-handlers: getSystemStatus package-list error: ${e.message}`); }
+  }
+
+  return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+}
+
+export async function initAtlisp() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    const code = `(if (null @::load-module)
+	   (progn
+	     (vl-load-com)
+	     (setq s strcat h"http"o(vlax-create-object (s"win"h".win"h"request.5.1"))
+		   v vlax-invoke e eval r read)(v o'open "get" (s h"://""atlisp.""cn/cloud"):vlax-true)
+		   (v o'send)
+		   (v o'WaitforResponse 1000)
+		   (e(r(vlax-get o'ResponseText)))))`;
+    try {
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: '已发送 @lisp 函数库加载代码到 CAD' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+export async function getSystemVariable(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const result = await cad.sendCommandWithResult(`(vl-princ-to-string (getvar "${escapeLispString(name)}"))`);
+        return { content: [{ type: 'text', text: result || 'nil' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+export async function setSystemVariable(name, value) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        await cad.sendCommand(`(setvar "${escapeLispString(name)}" ${value})\n`);
+        return { content: [{ type: 'text', text: `已设置 ${name} = ${value}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}

package/dist/handlers/constraint-handlers.js

@@ -0,0 +1,130 @@
+import { cad } from '../cad.js';
+import { mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
+
+function esc(s) {
+  return escapeLispString(String(s || ''));
+}
+
+function ptStr(pt) {
+  if (!pt) return '';
+  const parts = String(pt).split(',').map(Number);
+  return `(list ${parts[0] || 0} ${parts[1] || 0} ${parts[2] || 0})`;
+}
+
+export async function addGeomConstraint(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const ctype = esc(args.type);
+    const h1 = esc(args.handle1);
+    const h2 = esc(args.handle2 || '');
+    const p1 = ptStr(args.point1);
+    const p2 = ptStr(args.point2);
+
+    const code = `(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq assm (vla-get-associativeconstraints doc))
+  (setq e1 (handent "${h1}"))
+  ${h2 ? `(setq e2 (handent "${h2}"))` : '(setq e2 nil)'}
+  (if e1
+    (progn
+      (setq vobj1 (vlax-ename->vla-object e1))
+      ${h2 ? '(setq vobj2 (vlax-ename->vla-object e2))' : '(setq vobj2 nil)'}
+      (vlax-invoke assm 'AddConstraint "${ctype}" vobj1 ${h2 ? 'vobj2' : 'nil'} ${p1 || 'nil'} ${p2 || 'nil'})
+      (princ "ok")
+    )
+    (princ "nf")
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess(`几何约束已添加: ${ctype}`);
+    return mcpError(`添加约束失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function addDimConstraint(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const ctype = esc(args.type);
+    const h = esc(args.handle);
+    const val = parseFloat(args.value) || 0;
+    const p1 = ptStr(args.point1);
+    const p2 = ptStr(args.point2);
+
+    const code = `(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq assm (vla-get-associativeconstraints doc))
+  (setq e (handent "${h}"))
+  (if e
+    (progn
+      (setq vobj (vlax-ename->vla-object e))
+      (setq dim (vlax-invoke assm 'AddDimConstraint "${ctype}" vobj ${p1 || 'nil'} ${p2 || 'nil'} nil nil ${val} nil))
+      (princ "ok")
+    )
+    (princ "nf")
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess(`标注约束已添加: ${ctype} = ${val}`);
+    return mcpError(`添加标注约束失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function delConstraint(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const h = esc(args.handle);
+    const code = `(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq assm (vla-get-associativeconstraints doc))
+  (setq e (handent "${h}"))
+  (if e
+    (progn
+      (setq vobj (vlax-ename->vla-object e))
+      (vlax-invoke assm 'DeleteConstraintsOnObject vobj)
+      (princ "ok")
+    )
+    (princ "nf")
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess('约束已删除');
+    return mcpError(`删除约束失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function listConstraints() {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const code = `(progn
+  (vl-load-com)
+  (setq doc (vla-get-activedocument (vlax-get-acad-object)))
+  (setq assm (vla-get-associativeconstraints doc))
+  (setq result nil)
+  (vlax-for c (vla-get-constraints assm)
+    (setq result (cons (list
+      (cons "type" (vla-get-constrainttype c))
+      (cons "expression" (vla-get-expression c))
+      (cons "value" (vla-get-value c))
+    ) result))
+  )
+  (if result (vl-princ-to-string result) "[]")
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    return mcpSuccess(result || '[]');
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}

package/dist/handlers/dim-hatch-handlers.js

@@ -0,0 +1,340 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+function toSafePoint(pt) {
+  const parts = (Array.isArray(pt) ? pt : String(pt).split(/[,\s]+/)).map(Number);
+  return parts.filter(n => !isNaN(n)).join(' ');
+}
+
+export async function createDimension(type, points, style = {}) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    let dimCode = '';
+    const validTypes = ['ALIGNED', 'LINEAR', 'ORDINATE', 'RADIAL', 'DIAMETER', 'ANGULAR'];
+    const dimType = (type || 'ALIGNED').toUpperCase();
+
+    if (!validTypes.includes(dimType)) {
+        return { content: [{ type: 'text', text: `不支持的标注类型: ${type}` }], isError: true };
+    }
+
+    const defPt = toSafePoint(points.defPt || '0,0');
+    const pt1 = toSafePoint(points.pt1 || points.pt || '0,0');
+    const pt2 = toSafePoint(points.pt2 || '100,0');
+    const leaderLen = parseFloat(style.leaderLength) || 10;
+
+    switch (dimType) {
+        case 'ALIGNED':
+            dimCode = `(command "._DIMALIGNED" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+            break;
+        case 'LINEAR':
+            dimCode = `(command "._DIMLINEAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+            break;
+        case 'ORDINATE':
+            dimCode = `(command "._DIMORDINATE" (list ${pt1}) (list ${defPt}))`;
+            break;
+        case 'RADIAL':
+            dimCode = `(command "._DIMRADIUS" (list ${defPt}) "${leaderLen}")`;
+            break;
+        case 'DIAMETER':
+            dimCode = `(command "._DIMDIAMETER" (list ${defPt}) "${leaderLen}")`;
+            break;
+        case 'ANGULAR':
+            dimCode = `(command "._DIMANGULAR" (list ${pt1}) (list ${pt2}) (list ${defPt}))`;
+            break;
+    }
+
+    try {
+        await cad.sendCommand(dimCode + '\n');
+        return { content: [{ type: 'text', text: `已创建 ${dimType} 标注` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getDimensionValue(handle) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(handle)}"))
+            (progn
+                (setq ed (entget ent) typ (cdr (assoc 0 ed)))
+                (if (wcmatch typ "DIMENSION")
+                    (list
+                        "type" typ
+                        "handle" (cdr (assoc 5 ed))
+                        "layer" (cdr (assoc 8 ed))
+                        "style" (if (assoc 2 ed) (cdr (assoc 2 ed)) "Standard")
+                        "measurement" (if (assoc 42 ed) (rtos (cdr (assoc 42 ed)) 2 2) "0")
+                    )
+                    (list "error" "Not a dimension entity")
+                )
+            )
+            (list "error" "Entity not found")
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: result || '获取失败' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function createHatch(patternName, boundary, scale = 1, angle = 0) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (command "._BHATCH" "p" "${escapeLispString(patternName)}" "s" "s" "sc" ${scale} "an" ${angle} "")
+        "CREATED"
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result && result !== 'nil') {
+            return { content: [{ type: 'text', text: `已创建图案填充: ${patternName}` }] };
+        }
+        return { content: [{ type: 'text', text: '创建填充失败' }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setHatchProperties(handle, props) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    let propCode = '';
+    if (props.pattern) propCode += `(command "._HATCHEDIT" "${escapeLispString(handle)}" "p" "${escapeLispString(props.pattern)}")`;
+    if (props.scale) propCode += `(command "._HATCHEDIT" "${escapeLispString(handle)}" "s" ${parseFloat(props.scale) || 1})`;
+    if (props.angle) propCode += `(command "._HATCHEDIT" "${escapeLispString(handle)}" "an" ${parseFloat(props.angle) || 0})`;
+    if (props.color) propCode += `(command "._HATCHEDIT" "${escapeLispString(handle)}" "c" ${parseInt(props.color) || 256})`;
+
+    const code = `(progn
+        (vl-load-com)
+        ${propCode}
+        "UPDATED"
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: `已更新填充属性` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getBlockAttributes(blockHandle) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(blockHandle)}"))
+            (if (= (cdr (assoc 0 (entget ent))) "INSERT")
+                (progn
+                    (setq atts nil)
+                    (setq att (entnext ent))
+                    (while (and att (= (cdr (assoc 0 (entget att))) "ATTRIB"))
+                        (setq atts (cons
+                            (list (cdr (assoc 2 (entget att))) (cdr (assoc 1 (entget att))))
+                            atts))
+                        (setq att (entnext att)))
+                    (reverse atts))
+                (list "error" "Not a block reference"))
+            (list "error" "Entity not found"))
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: result || '无属性' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setBlockAttribute(blockHandle, tag, value) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(blockHandle)}"))
+            (progn
+                (setq att (entnext ent))
+                (while att
+                    (if (= (cdr (assoc 0 (entget att))) "ATTRIB")
+                        (if (= (strcase (cdr (assoc 2 (entget att)))) (strcase "${escapeLispString(tag)}"))
+                            (progn
+                                (entmod (subst (cons 1 "${escapeLispString(value)}") (assoc 1 (entget att)) (entget att)))
+                                (setq att nil)
+                            )
+                        )
+                    )
+                    (setq att (entnext att))
+                )
+                "UPDATED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'UPDATED' || result === '"UPDATED"') {
+            return { content: [{ type: 'text', text: `已设置属性 ${tag} = ${value}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function zoomToExtents() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (command "._ZOOM" "E")
+        "DONE"
+    )`;
+    try {
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: '已缩放到图形范围' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function zoomToWindow(p1, p2) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(command "._ZOOM" "W" (list ${toSafePoint(p1)}) (list ${toSafePoint(p2)}))`;
+    try {
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: '已缩放到窗口' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function createNamedView(viewName, center = null) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = center
+        ? `(command ".-VIEW" "S" "${escapeLispString(viewName)}" "C" (list ${toSafePoint(center)}))`
+        : `(command ".-VIEW" "S" "${escapeLispString(viewName)}")`;
+    try {
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: `已创建命名视图: ${viewName}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function restoreNamedView(viewName) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(command ".-VIEW" "R" "${escapeLispString(viewName)}")`;
+    try {
+        await cad.sendCommand(code + '\n');
+        return { content: [{ type: 'text', text: `已恢复视图: ${viewName}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function listNamedViews() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (setq views nil)
+        (while (setq v (tblnext "VIEW" (null views)))
+            (setq views (cons (cdr (assoc 2 v)) views))
+        )
+        (reverse views)
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: result || '无命名视图' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function exportDxf(outputPath, version = 'R2018') {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const versionMap = {
+        'R2018': 'AC1027', 'R2015': 'AC1024', 'R2013': 'AC1021',
+        'R2010': 'AC1018', 'R2007': 'AC1015', 'R2004': 'AC1012',
+        'R2000': 'AC1009'
+    };
+    const dxfVersion = versionMap[version] || 'AC1027';
+
+    const code = `(progn
+        (vl-load-com)
+        (vla-saveas (vla-get-activedocument (vlax-get-acad-object)) "${escapeLispString(outputPath)}" "${dxfVersion}")
+        "EXPORTED"
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'EXPORTED' || result === '"EXPORTED"') {
+            return { content: [{ type: 'text', text: `已导出 DXF: ${outputPath}` }] };
+        }
+        return { content: [{ type: 'text', text: `导出失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function exportDwf(outputPath) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (vla-export (vla-get-activedocument (vlax-get-acad-object)) "${escapeLispString(outputPath)}" "dwf")
+        "EXPORTED"
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'EXPORTED' || result === '"EXPORTED"') {
+            return { content: [{ type: 'text', text: `已导出 DWF: ${outputPath}` }] };
+        }
+        return { content: [{ type: 'text', text: `导出失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function batchSetLayer(handles, layerName) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    if (!Array.isArray(handles) || handles.length === 0) {
+        return { content: [{ type: 'text', text: '句柄列表为空' }], isError: true };
+    }
+
+    const handlesStr = handles.map(h => `"${escapeLispString(h)}"`).join(' ');
+    const code = `(progn
+        (vl-load-com)
+        (setq ss (ssadd))
+        ${handlesStr.split('\n').map(h => `(ssadd (handent ${h}) ss)`).join('\n')}
+        (command "._CHPROP" ss "" "LA" "${escapeLispString(layerName)}" "")
+        (strcat "Updated " (itoa ${handles.length}) " entities")
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: result || `已批量设置 ${handles.length} 个实体图层为 ${layerName}` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}