@atlisp/mcp 1.8.16 → 1.8.18

package/dist/handlers/draw-handlers.js

@@ -0,0 +1,175 @@
+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)))
+            (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
+            (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 };
+    }
+}

package/dist/handlers/edit-handlers.js

@@ -0,0 +1,179 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+export async function trimEntity(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 ent1 (handent "${escapeLispString(params.handle)}"))
+                (if (setq ent2 (handent "${escapeLispString(params.cuttingEdgeHandle)}"))
+                    (progn (command "_.TRIM" ent2 "" ent1 "" "") "OK")
+                    "CUT_EDGE_NOT_FOUND"
+                )
+                "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 };
+    }
+}
+
+export async function extendEntity(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 ent1 (handent "${escapeLispString(params.handle)}"))
+                (if (setq ent2 (handent "${escapeLispString(params.boundaryHandle)}"))
+                    (progn (command "_.EXTEND" ent2 "" ent1 "") "OK")
+                    "BOUNDARY_NOT_FOUND"
+                )
+                "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 };
+    }
+}
+
+export async function fillet(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 (and (setq ent1 (handent "${escapeLispString(params.handle1)}"))
+                     (setq ent2 (handent "${escapeLispString(params.handle2)}")))
+                (progn
+                    (command "_.FILLET" "R" ${params.radius} "_.FILLET" ent1 ent2)
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已圆角连接实体，半径=${params.radius}` }] };
+        }
+        return { content: [{ type: 'text', text: `圆角失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function chamfer(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 (and (setq ent1 (handent "${escapeLispString(params.handle1)}"))
+                     (setq ent2 (handent "${escapeLispString(params.handle2)}")))
+                (progn
+                    (command "_.CHAMFER" "D" ${params.distance1} ${params.distance2} "_.CHAMFER" ent1 ent2)
+                    "OK"
+                )
+                "NOTFOUND"
+            )
+        )`;
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已倒角连接实体，距离=${params.distance1},${params.distance2}` }] };
+        }
+        return { content: [{ type: 'text', text: `倒角失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function breakEntity(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 "_.BREAK" ent "${escapeLispString(params.point1)}" "${escapeLispString(params.point2)}")
+                    "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 };
+    }
+}
+
+export async function joinEntities(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) 1)
+                (progn (command "_.JOIN" ss "") "OK")
+                "TOO_FEW"
+            )
+        )`;
+        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 stretch(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 "_.STRETCH" ss "" "${escapeLispString(params.basePoint)}" "${escapeLispString(params.displacement)}")
+                    "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 };
+    }
+}

package/dist/handlers/entity-handlers.js

@@ -0,0 +1,196 @@
+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 };
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(handle)}"))
+            (progn
+                (setq ed (entget ent))
+                (list
+                    "type" (cdr (assoc 0 ed))
+                    "handle" (cdr (assoc 5 ed))
+                    "layer" (cdr (assoc 8 ed))
+                    "color" (if (assoc 62 ed) (cdr (assoc 62 ed)) 256)
+                    "linetype" (if (assoc 6 ed) (cdr (assoc 6 ed)) "ByLayer")
+                    "elevation" (if (assoc 38 ed) (cdr (assoc 38 ed)) 0.0)
+                )
+            )
+            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 };
+    }
+}
+
+export async function setEntityProperty(handle, property, value) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    let propCode = '';
+    switch (property) {
+        case 'layer':
+            propCode = `(cons 8 "${escapeLispString(value)}")`;
+            break;
+        case 'color':
+            propCode = `(cons 62 ${isNaN(Number(value)) ? 256 : Number(value)})`;
+            break;
+        case 'linetype':
+            propCode = `(cons 6 "${escapeLispString(value)}")`;
+            break;
+        case 'elevation':
+            propCode = `(cons 38 ${isNaN(Number(value)) ? 0 : Number(value)})`;
+            break;
+        default:
+            return { content: [{ type: 'text', text: `不支持的属性: ${property}` }], isError: true };
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ent (handent "${escapeLispString(handle)}"))
+            (progn
+                (setq ed (entget ent))
+                (entmod (append ed (list ${propCode})))
+                "OK"
+            )
+            "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 };
+    }
+}
+
+export async function deleteEntity(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
+                (entdel ent)
+                "DELETED"
+            )
+            "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 };
+    }
+}
+
+export async function selectEntities(filter) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    let filterCode = 'nil';
+    if (filter && (filter.type || filter.layer)) {
+        const items = [];
+        if (filter.type) items.push(`'(0 . "${escapeLispString(filter.type)}")`);
+        if (filter.layer) items.push(`'(8 . "${escapeLispString(filter.layer)}")`);
+        filterCode = `(list ${items.join(' ')})`;
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (if (setq ss (ssget "X" ${filterCode}))
+            (progn
+                (setq cnt (sslength ss) handles nil i 0)
+                (while (< i cnt)
+                    (setq handles (cons (cdr (assoc 5 (entget (ssname ss i)))) handles))
+                    (setq i (1+ i)))
+                (reverse handles)
+            )
+            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 };
+    }
+}
+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 }; }
+}