@atlisp/mcp 1.8.18 → 1.8.20

package/dist/handlers/draw-handlers.js

@@ -1,175 +1,128 @@
 import { cad } from '../cad.js';
-import { escapeLispString } from '../handler-utils.js';
-
-export async function drawLine(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.LINE" "${escapeLispString(params.p1)}" "${escapeLispString(params.p2)}" "")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制直线: ${params.p1} → ${params.p2}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawCircle(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.CIRCLE" "${escapeLispString(params.center)}" ${params.radius})`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制圆: 圆心 ${params.center}，半径 ${params.radius}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawArc(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(progn
-            (setq cen (list ${params.center}))
-            (setq r ${params.radius})
-            (setq ang1 (* pi (/ ${params.startAngle} 180.0)))
-            (setq ang2 (* pi (/ ${params.endAngle} 180.0)))
+import { withCadConnection, mcpSuccess, escapeLispString } from '../handler-utils.js';
+
+export const drawLine = withCadConnection(async (p1, p2) => {
+    await cad.sendCommand(`(command "_.LINE" "${escapeLispString(p1)}" "${escapeLispString(p2)}" "")`);
+    return mcpSuccess(`已绘制直线: ${p1} → ${p2}`);
+});
+
+export const drawCircle = withCadConnection(async (center, radius) => {
+    await cad.sendCommand(`(command "_.CIRCLE" "${escapeLispString(center)}" ${radius})`);
+    return mcpSuccess(`已绘制圆: 圆心 ${center}，半径 ${radius}`);
+});
+
+export const drawArc = withCadConnection(async (center, radius, startAngle, endAngle) => {
+    const code = `(progn
+            (setq cen (list ${center}))
+            (setq r ${radius})
+            (setq ang1 (* pi (/ ${startAngle} 180.0)))
+            (setq ang2 (* pi (/ ${endAngle} 180.0)))
             (command "_.ARC" "C" cen (polar cen ang1 r) (polar cen ang2 r))
         )`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制圆弧: 圆心 ${params.center}，半径 ${params.radius}，角度 ${params.startAngle}°→${params.endAngle}°` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawRectangle(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.RECTANG" "${escapeLispString(params.corner1)}" "${escapeLispString(params.corner2)}")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制矩形: ${params.corner1} — ${params.corner2}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawPolygon(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.POLYGON" ${params.sides} "${escapeLispString(params.center)}" "I" ${params.radius})`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制正${params.sides}边形: 中心 ${params.center}，半径 ${params.radius}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawEllipse(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.ELLIPSE" "C" "${escapeLispString(params.center)}" "${escapeLispString(params.majorAxis)}" "${escapeLispString(params.minorAxis)}")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已绘制椭圆: 中心 ${params.center}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawText(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const h = params.height || 2.5;
-        const code = `(command "_.TEXT" "${escapeLispString(params.point)}" ${h} "0" "${escapeLispString(params.text)}")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已创建单行文字: "${params.text}"` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawMtext(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const w = params.width || 0;
-        const code = `(command "_.MTEXT" "${escapeLispString(params.point)}" "W" ${w} "${escapeLispString(params.text)}" "")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已创建多行文字: "${params.text}"` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawPolyline(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const pts = params.points.split(/\s+/).filter(Boolean);
-        const pointArgs = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
-        const closeArg = params.closed ? ' "C"' : ' ""';
-        const code = `(command "_.PLINE" ${pointArgs}${closeArg})`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已创建多段线: ${pts.length} 个顶点` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawSpline(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const pts = params.points.split(/\s+/).filter(Boolean);
-        const pointArgs = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
-        const code = `(command "_.SPLINE" ${pointArgs} "" "" "")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已创建样条曲线: ${pts.length} 个控制点` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawPoint(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const code = `(command "_.POINT" "${escapeLispString(params.point)}")`;
-        await cad.sendCommand(code);
-        return { content: [{ type: 'text', text: `已创建点: ${params.point}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
-    }
-}
-
-export async function drawHatch(params) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const pattern = params.pattern || 'ANSI31';
-        const pts = params.points.split(/\s+/).filter(Boolean);
-        const ptList = pts.map(p => { const [x, y] = p.split(','); return `${x} ${y}`; }).join(' ');
-        const lispPts = `(list ${pts.map(p => `(list ${p})`).join(' ')})`;
-        const code = `(progn
+    await cad.sendCommand(code);
+    return mcpSuccess(`已绘制圆弧: 圆心 ${center}，半径 ${radius}，角度 ${startAngle}°→${endAngle}°`);
+});
+
+export const drawRectangle = withCadConnection(async (corner1, corner2) => {
+    await cad.sendCommand(`(command "_.RECTANG" "${escapeLispString(corner1)}" "${escapeLispString(corner2)}")`);
+    return mcpSuccess(`已绘制矩形: ${corner1} — ${corner2}`);
+});
+
+export const drawPolygon = withCadConnection(async (center, sides, radius) => {
+    await cad.sendCommand(`(command "_.POLYGON" ${sides} "${escapeLispString(center)}" "I" ${radius})`);
+    return mcpSuccess(`已绘制正${sides}边形: 中心 ${center}，半径 ${radius}`);
+});
+
+export const drawEllipse = withCadConnection(async (center, majorAxis, minorAxis) => {
+    await cad.sendCommand(`(command "_.ELLIPSE" "C" "${escapeLispString(center)}" "${escapeLispString(majorAxis)}" "${escapeLispString(minorAxis)}")`);
+    return mcpSuccess(`已绘制椭圆: 中心 ${center}`);
+});
+
+export const drawText = withCadConnection(async (text, point, height) => {
+    const h = height || 2.5;
+    await cad.sendCommand(`(command "_.TEXT" "${escapeLispString(point)}" ${h} "0" "${escapeLispString(text)}")`);
+    return mcpSuccess(`已创建单行文字: "${text}"`);
+});
+
+export const drawMtext = withCadConnection(async (text, point, width) => {
+    const w = width || 0;
+    await cad.sendCommand(`(command "_.MTEXT" "${escapeLispString(point)}" "W" ${w} "${escapeLispString(text)}" "")`);
+    return mcpSuccess(`已创建多行文字: "${text}"`);
+});
+
+export const drawPolyline = withCadConnection(async (points, closed) => {
+    const pts = points.split(/\s+/).filter(Boolean);
+    const pointArgs = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
+    const closeArg = closed ? ' "C"' : ' ""';
+    await cad.sendCommand(`(command "_.PLINE" ${pointArgs}${closeArg})`);
+    return mcpSuccess(`已创建多段线: ${pts.length} 个顶点`);
+});
+
+export const drawSpline = withCadConnection(async (points) => {
+    const pts = points.split(/\s+/).filter(Boolean);
+    const pointArgs = pts.map(p => `"${escapeLispString(p)}"`).join(' ');
+    await cad.sendCommand(`(command "_.SPLINE" ${pointArgs} "" "" "")`);
+    return mcpSuccess(`已创建样条曲线: ${pts.length} 个控制点`);
+});
+
+export const drawPoint = withCadConnection(async (point) => {
+    await cad.sendCommand(`(command "_.POINT" "${escapeLispString(point)}")`);
+    return mcpSuccess(`已创建点: ${point}`);
+});
+
+export const drawHatch = withCadConnection(async (points, pattern) => {
+    const pat = pattern || 'ANSI31';
+    const pts = points.split(/\s+/).filter(Boolean);
+    const lispPts = `(list ${pts.map(p => `(list ${p})`).join(' ')})`;
+    const boundaryCode = `(progn
             (setq pts ${lispPts})
             (entmake (list '(0 . "LWPOLYLINE") '(100 . "AcDbEntity") '(100 . "AcDbPolyline")
                 (cons 90 ${pts.length}) '(70 . 1)
                 (cons 10 (nth 0 pts)) (cons 10 (nth 1 pts))
             ))
         )`;
-        const code2 = `(command "_.HATCH" "${escapeLispString(pattern)}" "" "")`;
-        try {
-            await cad.sendCommand(code);
-            await cad.sendCommand(code2);
-        } catch(hErr) {
-            return { content: [{ type: 'text', text: `错误: ${hErr.message}` }], isError: true };
-        }
-        return { content: [{ type: 'text', text: `已创建图案填充: ${pattern}` }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    await cad.sendCommand(boundaryCode);
+    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/entity-handlers.js

@@ -1,11 +1,7 @@
 import { cad } from '../cad.js';
-import { log } from '../logger.js';
-import { escapeLispString } from '../handler-utils.js';
-
-export async function getEntity(handle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+import { withCadConnection, mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
 
+export const getEntity = withCadConnection(async (handle) => {
     const code = `(progn
         (vl-load-com)
         (if (setq ent (handent "${escapeLispString(handle)}"))
@@ -23,21 +19,14 @@ export async function getEntity(handle) {
             nil
         )
     )`;
-    try {
-        const result = await cad.sendCommandWithResult(code);
-        if (!result || result === 'nil') {
-            return { content: [{ type: 'text', text: `未找到实体: ${handle}` }], isError: true };
-        }
-        return { content: [{ type: 'text', text: result }] };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === 'nil') {
+        return mcpError(`未找到实体: ${handle}`);
     }
-}
-
-export async function setEntityProperty(handle, property, value) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    return mcpSuccess(result);
+});
 
+export const setEntityProperty = withCadConnection(async (handle, property, value) => {
     let propCode = '';
     switch (property) {
         case 'layer':
@@ -53,7 +42,7 @@ export async function setEntityProperty(handle, property, value) {
             propCode = `(cons 38 ${isNaN(Number(value)) ? 0 : Number(value)})`;
             break;
         default:
-            return { content: [{ type: 'text', text: `不支持的属性: ${property}` }], isError: true };
+            return mcpError(`不支持的属性: ${property}`);
     }
 
     const code = `(progn
@@ -67,21 +56,14 @@ export async function setEntityProperty(handle, property, value) {
             "NOTFOUND"
         )
     )`;
-    try {
-        const result = await cad.sendCommandWithResult(code);
-        if (result === 'OK' || result === '"OK"') {
-            return { content: [{ type: 'text', text: `已设置实体 ${handle} 的 ${property} 为 ${value}` }] };
-        }
-        return { content: [{ type: 'text', text: `操作失败: ${result}` }], isError: true };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'OK' || result === '"OK"') {
+        return mcpSuccess(`已设置实体 ${handle} 的 ${property} 为 ${value}`);
     }
-}
-
-export async function deleteEntity(handle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    return mcpError(`操作失败: ${result}`);
+});
 
+export const deleteEntity = withCadConnection(async (handle) => {
     const code = `(progn
         (vl-load-com)
         (if (setq ent (handent "${escapeLispString(handle)}"))
@@ -92,21 +74,14 @@ export async function deleteEntity(handle) {
             "NOTFOUND"
         )
     )`;
-    try {
-        const result = await cad.sendCommandWithResult(code);
-        if (result === 'DELETED' || result === '"DELETED"') {
-            return { content: [{ type: 'text', text: `已删除实体: ${handle}` }] };
-        }
-        return { content: [{ type: 'text', text: `删除失败: ${result}` }], isError: true };
-    } catch (e) {
-        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'DELETED' || result === '"DELETED"') {
+        return mcpSuccess(`已删除实体: ${handle}`);
     }
-}
-
-export async function selectEntities(filter) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    return mcpError(`删除失败: ${result}`);
+});
 
+export const selectEntities = withCadConnection(async (filter) => {
     let filterCode = 'nil';
     if (filter && (filter.type || filter.layer)) {
         const items = [];
@@ -128,69 +103,44 @@ export async function selectEntities(filter) {
             nil
         )
     )`;
-    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 };
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === 'nil') {
+        return mcpSuccess('未找到符合条件的实体');
     }
-}
-export async function bringToFront(handle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_F")\n`);
-        return { content: [{ type: 'text', text: `已置于最前: ${handle}` }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function sendToBack(handle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_B")\n`);
-        return { content: [{ type: 'text', text: `已置于最后: ${handle}` }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function bringAbove(handle, referenceHandle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_A" (handent "${escapeLispString(referenceHandle)}"))\n`);
-        return { content: [{ type: 'text', text: `已置于 ${referenceHandle} 之上` }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function sendBelow(handle, referenceHandle) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_U" (handent "${escapeLispString(referenceHandle)}"))\n`);
-        return { content: [{ type: 'text', text: `已置于 ${referenceHandle} 之下` }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function selectAll() {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const result = await cad.sendCommandWithResult('(progn (setq ss (ssget "_X")) (setq handles nil) (setq i 0) (if ss (repeat (sslength ss) (setq handles (cons (cdr (assoc 5 (entget (ssname ss i)))) handles)) (setq i (1+ i)))) (vl-prin1-to-string (reverse handles)))');
-        return { content: [{ type: 'text', text: result || '[]' }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function selectLast() {
-    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 (list (cdr (assoc 5 (entget (entlast))))))');
-        return { content: [{ type: 'text', text: result || 'nil' }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
-export async function selectByColor(colorIndex) {
-    if (!cad.connected) { await cad.connect(); }
-    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
-    try {
-        const result = await cad.sendCommandWithResult(`(progn (setq ss (ssget "_X" (list (cons 62 ${colorIndex})))) (setq handles nil) (setq i 0) (if ss (repeat (sslength ss) (setq handles (cons (cdr (assoc 5 (entget (ssname ss i)))) handles)) (setq i (1+ i)))) (vl-prin1-to-string (reverse handles)))`);
-        return { content: [{ type: 'text', text: result || '[]' }] };
-    } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
-}
+    return mcpSuccess(result);
+});
+
+export const bringToFrontEntity = withCadConnection(async (handle) => {
+    await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_F")\n`);
+    return mcpSuccess(`已置于最前: ${handle}`);
+});
+
+export const sendToBackEntity = withCadConnection(async (handle) => {
+    await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_B")\n`);
+    return mcpSuccess(`已置于最后: ${handle}`);
+});
+
+export const bringAboveEntity = withCadConnection(async (handle, referenceHandle) => {
+    await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_A" (handent "${escapeLispString(referenceHandle)}"))\n`);
+    return mcpSuccess(`已置于 ${referenceHandle} 之上`);
+});
+
+export const sendBelowEntity = withCadConnection(async (handle, referenceHandle) => {
+    await cad.sendCommand(`(command "_.DRAWORDER" (handent "${escapeLispString(handle)}") "" "_U" (handent "${escapeLispString(referenceHandle)}"))\n`);
+    return mcpSuccess(`已置于 ${referenceHandle} 之下`);
+});
+
+export const selectAll = withCadConnection(async () => {
+    const result = await cad.sendCommandWithResult('(progn (setq ss (ssget "_X")) (setq handles nil) (setq i 0) (if ss (repeat (sslength ss) (setq handles (cons (cdr (assoc 5 (entget (ssname ss i)))) handles)) (setq i (1+ i)))) (vl-prin1-to-string (reverse handles)))');
+    return mcpSuccess(result || '[]');
+});
+
+export const selectLast = withCadConnection(async () => {
+    const result = await cad.sendCommandWithResult('(vl-princ-to-string (list (cdr (assoc 5 (entget (entlast))))))');
+    return mcpSuccess(result || 'nil');
+});
+
+export const selectByColor = withCadConnection(async (colorIndex) => {
+    const result = await cad.sendCommandWithResult(`(progn (setq ss (ssget "_X" (list (cons 62 ${colorIndex})))) (setq handles nil) (setq i 0) (if ss (repeat (sslength ss) (setq handles (cons (cdr (assoc 5 (entget (ssname ss i)))) handles)) (setq i (1+ i)))) (vl-prin1-to-string (reverse handles)))`);
+    return mcpSuccess(result || '[]');
+});