@atlisp/mcp 1.8.16 → 1.8.17

package/dist/handlers/style-handlers.js

@@ -0,0 +1,162 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected, escapeLispString } from '../handler-utils.js';
+
+export async function createDimensionStyle(name, color = 'bylayer', arrow = 'ClosedFilled', textStyle = '') {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (command "_.dimstyle" "s" "${escapeLispString(name)}")
+  (command "_.dimstyle" "c" "${escapeLispString(color)}" "_.dimstyle" "a" "${escapeLispString(arrow)}")
+  (if (> (strlen "${escapeLispString(textStyle)}") 0) (command "_.dimstyle" "t" "${escapeLispString(textStyle)}"))
+  (princ "${escapeLispString(name)}")
+)`);
+    return mcpSuccess(JSON.stringify({ name, color, arrow, textStyle, created: !!result }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function setDimensionStyleVariable(styleName, variable, value) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (command "_.dimstyle" "s" "${escapeLispString(styleName)}")
+  (command "_.dimstyle" "${escapeLispString(variable)}" "${escapeLispString(value)}")
+  (princ "ok")
+)`);
+    return mcpSuccess(JSON.stringify({ styleName, variable, value, set: result?.includes('ok') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listDimensionStyles() {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq styles nil)
+  (while (setq x (tblnext "dimstyle" (null styles)))
+    (setq styles (cons (cdr (assoc 2 x)) styles)))
+  (princ (vl-prin1-to-string (reverse styles)))
+)`);
+    let styles = [];
+    if (result && result !== 'nil') { try { styles = JSON.parse(result); } catch { styles = result.replace(/[()]/g, '').split(' ').filter(Boolean); } }
+    return mcpSuccess(JSON.stringify({ styles, count: styles.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function getDimensionStyleVariable(styleName, variable) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (command "_.dimstyle" "s" "${escapeLispString(styleName)}")
+  (command "_.dimstyle" "${escapeLispString(variable)}")
+  (princ "done")
+)`);
+    return mcpSuccess(JSON.stringify({ styleName, variable, value: result }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createTextStyle(name, fontFile, height = 0, width = 1, angle = 0) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (command "_.style" "${escapeLispString(name)}" "${escapeLispString(fontFile)}" "${height}" "${width}" "${angle}" "n" "n")
+  (princ "${escapeLispString(name)}")
+)`);
+    return mcpSuccess(JSON.stringify({ name, fontFile, height, width, angle, created: !!result }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listTextStyles() {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq styles nil)
+  (while (setq x (tblnext "style" (null styles)))
+    (setq styles (cons (cdr (assoc 2 x)) styles)))
+  (princ (vl-prin1-to-string (reverse styles)))
+)`);
+    let styles = [];
+    if (result && result !== 'nil') { try { styles = JSON.parse(result); } catch { styles = []; } }
+    return mcpSuccess(JSON.stringify({ styles, count: styles.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createLinetype(name, description, pattern) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.linetype" "c" "${escapeLispString(name)}" "${escapeLispString(description)}" "${escapeLispString(pattern)}" "")`); return mcpSuccess(JSON.stringify({ name, description })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function loadLinetype(linetypeName, filePath) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.linetype" "l" "${escapeLispString(linetypeName)}" "${escapeLispString(filePath)}")`); return mcpSuccess(JSON.stringify({ linetypeName, filePath })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listLinetypes() {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq lts nil)
+  (while (setq x (tblnext "ltype" (null lts)))
+    (setq lts (cons (cdr (assoc 2 x)) lts)))
+  (princ (vl-prin1-to-string (reverse lts)))
+)`);
+    let linetypes = [];
+    if (result && result !== 'nil') { try { linetypes = JSON.parse(result); } catch { linetypes = []; } }
+    return mcpSuccess(JSON.stringify({ linetypes, count: linetypes.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createMLeaderStyle(name) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq mls (vla-get-mleaderstyles (vla-get-activedocument (vlax-get-acad-object))))
+  (vla-add mls "${escapeLispString(name)}")
+  (princ "${escapeLispString(name)}")
+)`);
+    return mcpSuccess(JSON.stringify({ name, created: !!result }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function setMLeaderStyleProperty(styleName, property, value) {
+  try {
+    await ensureCadConnected();
+    const valStr = typeof value === 'string' ? `"${escapeLispString(value)}"` : String(value);
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq mls (vla-get-mleaderstyles (vla-get-activedocument (vlax-get-acad-object))))
+  (vlax-for style mls (if (= (vla-get-name style) "${escapeLispString(styleName)}") (setf (vla-get-${escapeLispString(property)} style) ${valStr})))
+  (princ "ok")
+)`);
+    return mcpSuccess(JSON.stringify({ styleName, property, value, set: result?.includes('ok') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listMLeaderStyles() {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq mls (vla-get-mleaderstyles (vla-get-activedocument (vlax-get-acad-object))) styles nil)
+  (vlax-for style mls (setq styles (cons (vla-get-name style) styles)))
+  (princ (vl-prin1-to-string (reverse styles)))
+)`);
+    let styles = [];
+    if (result && result !== 'nil') { try { styles = JSON.parse(result); } catch { styles = []; } }
+    return mcpSuccess(JSON.stringify({ styles, count: styles.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createCloudLine(startPoint, endPoint, bulge = 1, arcRadius = 0) {
+  try { await ensureCadConnected(); const start = Array.isArray(startPoint) ? startPoint.join(' ') : startPoint; const end = Array.isArray(endPoint) ? endPoint.join(' ') : endPoint; await cad.sendCommand(`(command "_.revcloud" "${escapeLispString(start)}" "${escapeLispString(end)}" "${bulge}" "")`); return mcpSuccess(JSON.stringify({ startPoint: start, endPoint: end, bulge })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function convertToCloudLine(handle) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.revcloud" (handent "${escapeLispString(handle)}") "")`); return mcpSuccess(JSON.stringify({ handle, converted: true })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function setCloudLineStyle(bulgeFactor = 1, arcRadius = 0.5) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(setvar "revcldbulge" ${bulgeFactor})`); return mcpSuccess(JSON.stringify({ bulgeFactor, arcRadius })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createMultileaderStyle(name) { return await createMLeaderStyle(name); }
+export async function setMultileaderStyleProperty(styleName, property, value) { return await setMLeaderStyleProperty(styleName, property, value); }
+export async function listMultileaderStyles() { return await listMLeaderStyles(); }

package/dist/handlers/text-handlers.js

@@ -0,0 +1,198 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+export async function findText(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const caseSensitive = params.caseSensitive ? 'T' : 'nil';
+        const code = `(progn
+            (vl-load-com)
+            (setq ss (ssget "X" (list (cons 0 "TEXT,MTEXT") (cons 1 "${escapeLispString(params.pattern)}"))))
+            (if ss
+                (progn
+                    (setq cnt (sslength ss) results nil i 0)
+                    (while (< i cnt)
+                        (setq ent (ssname ss i))
+                        (setq h (cdr (assoc 5 (entget ent))))
+                        (setq txt (cdr (assoc 1 (entget ent))))
+                        (setq results (cons (list h txt) results))
+                        (setq i (1+ i)))
+                    (reverse results)
+                )
+                nil
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (!result || result === 'nil') {
+            return { content: [{ type: 'text', text: `未找到匹配 "${params.pattern}" 的文本` }] };
+        }
+        return { content: [{ type: 'text', text: result }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function replaceText(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (setq cnt 0)
+            (if (setq ss (ssget "X" (list (cons 0 "TEXT,MTEXT") (cons 1 "${escapeLispString(params.pattern)}"))))
+                (progn
+                    (setq i 0)
+                    (while (< i (sslength ss))
+                        (setq ent (ssname ss i))
+                        (setq ed (entget ent))
+                        (setq oldTxt (cdr (assoc 1 ed)))
+                        (entmod (subst (cons 1 "${escapeLispString(params.replacement)}") (assoc 1 ed) ed))
+                        (setq cnt (1+ cnt))
+                        (setq i (1+ i)))
+                )
+            )
+            cnt
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: `已替换 ${result || 0} 处文本` }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setTextHeight(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq ent (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setq ed (entget ent))
+                    (entmod (subst (cons 40 ${params.height}) (assoc 40 ed) ed))
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置文字高度: ${params.height}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setTextStyleName(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq ent (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setq ed (entget ent))
+                    (entmod (subst (cons 7 "${escapeLispString(params.styleName)}") (assoc 7 ed) ed))
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置文字样式: ${params.styleName}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function justifyText(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const justMap = {
+            'TL': 1, 'TC': 2, 'TR': 3,
+            'ML': 4, 'MC': 5, 'MR': 6,
+            'BL': 7, 'BC': 8, 'BR': 9,
+            'L': 0, 'C': 1, 'R': 2,
+            'M': 4, 'B': 8, 'T': 2
+        };
+        const justVal = justMap[params.justification] || 0;
+        const code = `(progn
+            (vl-load-com)
+            (if (setq ent (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (setq ed (entget ent))
+                    (if (assoc 72 ed)
+                        (entmod (subst (cons 72 ${justVal}) (assoc 72 ed) ed))
+                        (entmod (append ed (list (cons 72 ${justVal}))))
+                    )
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置文字对齐方式: ${params.justification}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function convertTextToMtext(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const handleList = params.handles
+            .map(h => `(setq ss (ssadd (handent "${escapeLispString(h)}") ss))`)
+            .join('\n');
+        const code = `(progn
+            (vl-load-com)
+            (setq ss (ssadd))
+            ${handleList}
+            (if (> (sslength ss) 0)
+                (progn (command "_.TXT2MTXT" ss "") "OK")
+                "NO_ENTITIES"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已转换 ${params.handles.length} 个单行文字为多行文字` }] };
+        }
+        return { content: [{ type: 'text', text: `转换失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function explodeText(params) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try {
+        const code = `(progn
+            (vl-load-com)
+            (if (setq ent (handent "${escapeLispString(params.handle)}"))
+                (progn
+                    (command "_.TXTEXP" ent "")
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已分解文字为线: ${params.handle}` }] };
+        }
+        return { content: [{ type: 'text', text: `分解失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}

package/dist/handlers/ucs-layout-handlers.js

@@ -0,0 +1,271 @@
+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 createUcs(name, origin = '0,0,0', xAxis = '1,0,0', yAxis = '0,1,0') {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (not (tblsearch "UCS" "${escapeLispString(name)}"))
+            (progn
+                (command "._UCS" "N" "${escapeLispString(name)}")
+                (command "._UCS" "${escapeLispString(name)}" "O" (list ${toSafePoint(origin)}))
+                (command "._UCS" "${escapeLispString(name)}" "X" (list ${toSafePoint(xAxis)}))
+                (command "._UCS" "${escapeLispString(name)}" "Y" (list ${toSafePoint(yAxis)}))
+                "CREATED"
+            )
+            "EXISTS"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'CREATED' || result === '"CREATED"') {
+            return { content: [{ type: 'text', text: `已创建 UCS: ${name}` }] };
+        }
+        if (result === 'EXISTS' || result === '"EXISTS"') {
+            return { content: [{ type: 'text', text: `UCS 已存在: ${name}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: `创建失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setUcs(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (tblsearch "UCS" "${escapeLispString(name)}")
+            (progn
+                (command "._UCS" "R" "${escapeLispString(name)}")
+                "SET"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'SET' || result === '"SET"') {
+            return { content: [{ type: 'text', text: `已切换到 UCS: ${name}` }] };
+        }
+        return { content: [{ type: 'text', text: `UCS 不存在: ${name}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function listUcs() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (setq ucsList nil)
+        (while (setq u (tblnext "UCS" (null ucsList)))
+            (setq ucsList (cons (cdr (assoc 2 u)) ucsList))
+        )
+        (reverse ucsList)
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (!result || result === 'nil') {
+            return { content: [{ type: 'text', text: '当前没有 UCS' }] };
+        }
+        return { content: [{ type: 'text', text: result }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function deleteUcs(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (tblsearch "UCS" "${escapeLispString(name)}")
+            (progn
+                (command "._UCS" "D" "${escapeLispString(name)}")
+                "DELETED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'DELETED' || result === '"DELETED"') {
+            return { content: [{ type: 'text', text: `已删除 UCS: ${name}` }] };
+        }
+        return { content: [{ type: 'text', text: `UCS 不存在: ${name}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getCurrentUcs() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (vla-get-activeutilities (vla-get-document (vla-get-application (vlax-get-acad-object))))
+        (vl-prin1-to-string (getvar "UCSNAME"))
+    )`;
+    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 createLayout(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (setq @layouts (layoutlist))
+        (if (member "${escapeLispString(name)}" @layouts)
+            "EXISTS"
+            (progn
+                (command "._LAYOUT" "N" "${escapeLispString(name)}")
+                "CREATED"
+            )
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'CREATED' || result === '"CREATED"') {
+            return { content: [{ type: 'text', text: `已创建布局: ${name}` }] };
+        }
+        if (result === 'EXISTS' || result === '"EXISTS"') {
+            return { content: [{ type: 'text', text: `布局已存在: ${name}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: `创建失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setLayout(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (setq @result "NOTFOUND")
+        (vlax-for layout (vla-get-layouts (vla-get-activedocument (vlax-get-acad-object)))
+            (if (= (vla-get-name layout) "${escapeLispString(name)}")
+                (progn
+                    (vla-put-activelayout (vla-get-activedocument (vlax-get-acad-object)) layout)
+                    (setq @result "SET")
+                )
+            )
+        )
+        @result
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'SET' || result === '"SET"') {
+            return { content: [{ type: 'text', text: `已切换到布局: ${name}` }] };
+        }
+        return { content: [{ type: 'text', text: `布局不存在: ${name}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function listLayouts() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (vl-prin1-to-string (layoutlist))
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (!result || result === 'nil') {
+            return { content: [{ type: 'text', text: '当前没有布局' }] };
+        }
+        return { content: [{ type: 'text', text: result }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function deleteLayout(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    if (name === 'Model' || name === '模型') {
+        return { content: [{ type: 'text', text: '无法删除模型空间' }], isError: true };
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (if (member "${escapeLispString(name)}" (layoutlist))
+            (progn
+                (command "._LAYOUT" "D" "${escapeLispString(name)}")
+                "DELETED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'DELETED' || result === '"DELETED"') {
+            return { content: [{ type: 'text', text: `已删除布局: ${name}` }] };
+        }
+        return { content: [{ type: 'text', text: `布局不存在: ${name}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getCurrentLayout() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(vl-prin1-to-string (getvar "CTAB"))`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        return { content: [{ type: 'text', text: result || 'Model' }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function renameLayout(oldName, newName) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (member "${escapeLispString(oldName)}" (layoutlist))
+            (progn
+                (command ".-LAYOUT" "R" "${escapeLispString(oldName)}" "${escapeLispString(newName)}")
+                "RENAMED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'RENAMED' || result === '"RENAMED"') {
+            return { content: [{ type: 'text', text: `已将布局 ${oldName} 重命名为 ${newName}` }] };
+        }
+        return { content: [{ type: 'text', text: `布局不存在: ${oldName}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}