@atlisp/mcp 1.8.16 → 1.8.17

package/dist/atlisp-mcp.js

@@ -1123,13 +1123,13 @@ var init_constants = __esm({
       logging: {},
       completions: {},
       experimental: {
-        pipeline_engine: {},
-        triggers: {},
-        repl: {},
-        webhooks: {},
-        agent_context: {},
-        rate_limiting: {},
-        request_dedup: {}
+        pipeline_engine: true,
+        triggers: true,
+        repl: true,
+        webhooks: true,
+        agent_context: true,
+        rate_limiting: true,
+        request_dedup: true
       }
     };
     MOCK_PACKAGES = [];

package/dist/handlers/3d-handlers.js

@@ -0,0 +1,128 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected, escapeLispString } from '../handler-utils.js';
+
+function parsePoint(point) {
+  if (Array.isArray(point)) return point.join(' ');
+  if (typeof point === 'string') return point;
+  return '0,0,0';
+}
+
+export async function createBox(center, length, width, height) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.box" "${escapeLispString(pt)}" "${length}" "${width}" "${height}" "")`); return mcpSuccess(JSON.stringify({ center: pt, dimensions: { length, width, height } })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createSphere(center, radius) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.sphere" "${escapeLispString(pt)}" "${radius}" "")`); return mcpSuccess(JSON.stringify({ center: pt, radius })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createCylinder(center, radius, height) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.cylinder" "${escapeLispString(pt)}" "${radius}" "${height}" "")`); return mcpSuccess(JSON.stringify({ center: pt, radius, height })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createCone(center, radius, height) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.cone" "${escapeLispString(pt)}" "${radius}" "${height}" "")`); return mcpSuccess(JSON.stringify({ center: pt, radius, height })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createTorus(center, majorRadius, minorRadius) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.torus" "${escapeLispString(pt)}" "${majorRadius}" "${minorRadius}" "")`); return mcpSuccess(JSON.stringify({ center: pt, majorRadius, minorRadius })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createWedge(center, length, width, height) {
+  try { await ensureCadConnected(); const pt = parsePoint(center); await cad.sendCommand(`(command "_.wedge" "${escapeLispString(pt)}" "${length}" "${width}" "${height}" "")`); return mcpSuccess(JSON.stringify({ center: pt, dimensions: { length, width, height } })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function create3DFace(points) {
+  try { await ensureCadConnected(); const ptList = Array.isArray(points) ? points.join(' ') : points; await cad.sendCommand(`(command "_.3dface" ${ptList} "")`); return mcpSuccess(JSON.stringify({ points })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createMesh(rows, columns, points) {
+  try { await ensureCadConnected(); const ptList = typeof points === 'string' ? points : (Array.isArray(points) ? points.join(' ') : points); await cad.sendCommand(`(command "_.mesh" "${rows}" "${columns}" ${ptList} "")`); return mcpSuccess(JSON.stringify({ rows, columns })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function extrudeSolid(profileHandle, height, taperAngle = 0) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.extrude" (handent "${escapeLispString(profileHandle)}") "${height}" "${taperAngle}" "")`); return mcpSuccess(JSON.stringify({ profileHandle, height, taperAngle })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function revolveSolid(profileHandle, axisStart, axisEnd, angle = 360) {
+  try { await ensureCadConnected(); const startPt = parsePoint(axisStart); const endPt = parsePoint(axisEnd); await cad.sendCommand(`(command "_.revolve" (handent "${escapeLispString(profileHandle)}") "${escapeLispString(startPt)}" "${escapeLispString(endPt)}" "${angle}" "")`); return mcpSuccess(JSON.stringify({ profileHandle, axisStart: startPt, axisEnd: endPt, angle })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function create3DPolyline(points) {
+  try { await ensureCadConnected(); const ptList = Array.isArray(points) ? points.map(p => parsePoint(p)).join(' ') : points; await cad.sendCommand(`(command "_.3dpoly" ${ptList} "")`); return mcpSuccess(JSON.stringify({ points })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createRegion(handles) {
+  try { await ensureCadConnected(); const handleList = Array.isArray(handles) ? handles : handles.split(',').map(h => h.trim()); const handleStr = handleList.map(h => `(handent "${escapeLispString(h)}")`).join(' '); await cad.sendCommand(`(command "_.region" ${handleStr} "")`); return mcpSuccess(JSON.stringify({ handleCount: handleList.length })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function booleanUnion(handles) {
+  try { await ensureCadConnected(); const handleList = Array.isArray(handles) ? handles : handles.split(',').map(h => h.trim()); await cad.sendCommand(`(command "_.union" ${handleList.map(h => `(handent "${escapeLispString(h)}")`).join(' ')} "")`); return mcpSuccess(JSON.stringify({ operation: 'union' })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function booleanSubtract(handles, subtractFromHandles = []) {
+  try {
+    await ensureCadConnected();
+    const handleList = Array.isArray(handles) ? handles : handles.split(',').map(h => h.trim());
+    const fromList = subtractFromHandles.length ? (Array.isArray(subtractFromHandles) ? subtractFromHandles : subtractFromHandles.split(',').map(h => h.trim())) : [handleList.shift()];
+    const fromStr = fromList.map(h => `(handent "${escapeLispString(h)}")`).join(' ');
+    const subtractStr = handleList.map(h => `(handent "${escapeLispString(h)}")`).join(' ');
+    await cad.sendCommand(`(command "_.subtract" ${fromStr} "" ${subtractStr} "")`);
+    return mcpSuccess(JSON.stringify({ subtractFrom: fromList, subtractThese: handleList }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function booleanIntersect(handles) {
+  try { await ensureCadConnected(); const handleList = Array.isArray(handles) ? handles : handles.split(',').map(h => h.trim()); await cad.sendCommand(`(command "_.intersect" ${handleList.map(h => `(handent "${escapeLispString(h)}")`).join(' ')} "")`); return mcpSuccess(JSON.stringify({ operation: 'intersect' })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function sliceSolid(solidHandle, planePoint, planeNormal, keepBoth = true) {
+  try { await ensureCadConnected(); const pt = parsePoint(planePoint); const normal = parsePoint(planeNormal); const side = keepBoth ? 'Both' : 'No'; await cad.sendCommand(`(command "_.slice" (handent "${escapeLispString(solidHandle)}") "${escapeLispString(pt)}" "${escapeLispString(normal)}" "${side}")`); return mcpSuccess(JSON.stringify({ solidHandle, planePoint: pt, planeNormal: normal, keepBoth })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createLoftSurface(profileHandles, guideHandles = []) {
+  try {
+    await ensureCadConnected();
+    const profileList = Array.isArray(profileHandles) ? profileHandles : profileHandles.split(',').map(h => h.trim());
+    const guideList = Array.isArray(guideHandles) ? guideHandles : guideHandles.split(',').map(h => h.trim());
+    const cmd = `(progn
+  (command "_.loft")
+  ${profileList.map(h => `(handent "${escapeLispString(h)}")`).join(' ')}
+  ${guideList.length > 0 ? guideList.map(h => `(handent "${escapeLispString(h)}")`).join(' ') : ''}
+  ""
+)`;
+    await cad.sendCommand(cmd);
+    return mcpSuccess(JSON.stringify({ profileCount: profileList.length, guideCount: guideList.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function get3DSolidInfo(handle) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent
+    (progn
+      (setq vla (vlax-ename->vla-object ent))
+      (princ (vl-prin1-to-string (list
+        (cons "type" (vla-get-objectname vla))
+        (cons "volume" (vla-get-volume vla))
+        (cons "surfaceArea" (vla-get-area vla))
+      )))
+    )
+    (princ "nil")
+  )
+)`);
+    let info = {};
+    if (result && result !== 'nil') { try { info = JSON.parse(result); } catch { info = {}; } }
+    return mcpSuccess(JSON.stringify({ handle, info }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function thickenSurface(surfaceHandle, thickness) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.thicken" (handent "${escapeLispString(surfaceHandle)}") "${thickness}")`); return mcpSuccess(JSON.stringify({ surfaceHandle, thickness })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function offsetSurface(surfaceHandle, distance) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.offset" (handent "${escapeLispString(surfaceHandle)}") "${distance}")`); return mcpSuccess(JSON.stringify({ surfaceHandle, distance })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}

package/dist/handlers/batch-handlers.js

@@ -0,0 +1,260 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected, escapeLispString } from '../handler-utils.js';
+
+function parseHandleList(handles) {
+  if (typeof handles === 'string') {
+    const trimmed = handles.trim();
+    if (trimmed.startsWith('[')) {
+      try { handles = JSON.parse(trimmed); } catch { handles = handles.split(',').map(h => h.trim()); }
+    } else {
+      handles = handles.split(',').map(h => h.trim());
+    }
+  }
+  if (!Array.isArray(handles)) handles = [handles];
+  return handles;
+}
+
+export async function batchRename(handles, newNameTemplate, startNum = 1) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (let i = 0; i < handleList.length; i++) {
+      const handle = handleList[i];
+      const newName = newNameTemplate.replace('{n}', String(startNum + i).padStart(3, '0'));
+      try {
+        await cad.sendCommand(`(_vlax-set-property (vla-item (vla-get-blocks (vla-get-document (vlax-ename->vla-object (handent "${escapeLispString(handle)}")))) (handent "${escapeLispString(handle)}")) 'Name "${escapeLispString(newName)}")`);
+        results.push({ handle, newName, success: true });
+      } catch (e) {
+        results.push({ handle, error: e.message, success: false });
+      }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchMove(handles, fromLayer, toLayer) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        const cond = fromLayer ? `(= (cdr (assoc 8 (entget ent))) "${escapeLispString(fromLayer)}")` : 't';
+        await cad.sendCommand(`(progn (setq ent (handent "${escapeLispString(handle)}")) (if ${cond} (entmod (subst (cons 8 "${escapeLispString(toLayer)}") (assoc 8 (entget ent)) (entget ent)))))`);
+        results.push({ handle, fromLayer, toLayer, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchCopy(handles, dx, dy, dz = 0) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(command "_.copy" (handent "${escapeLispString(handle)}") "" (list 0 0 0) (list ${dx} ${dy} ${dz}))`);
+        results.push({ originalHandle: handle, offset: { dx, dy, dz }, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchDelete(handles) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(entdel (handent "${escapeLispString(handle)}"))`);
+        results.push({ handle, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchSetColor(handles, color) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(progn (setq ent (handent "${escapeLispString(handle)}")) (entmod (subst (cons 62 ${color}) (assoc 62 (entget ent)) (entget ent))) (princ "ok"))`);
+        results.push({ handle, color, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchExplode(handles) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(progn (command "_.explode" (handent "${escapeLispString(handle)}")) (princ "ok"))`);
+        results.push({ handle, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchMirror(handles, startPoint, endPoint, deleteOriginal = false) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        const pt1 = typeof startPoint === 'string' ? startPoint : startPoint.join(' ');
+        const pt2 = typeof endPoint === 'string' ? endPoint : endPoint.join(' ');
+        const delOpt = deleteOriginal ? 'yes' : 'no';
+        await cad.sendCommand(`(progn (command "_.mirror" (handent "${escapeLispString(handle)}") "" "${escapeLispString(pt1)}" "${escapeLispString(pt2)}" "${delOpt}") (princ "ok"))`);
+        results.push({ handle, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchOffset(handles, distance, side = 'both') {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        if (side === 'both') {
+          await cad.sendCommand(`(command "_.offset" ${distance} (handent "${escapeLispString(handle)}") (list 0 0 0))`);
+        } else {
+          await cad.sendCommand(`(command "_.offset" ${distance} (handent "${escapeLispString(handle)}"))`);
+        }
+        results.push({ handle, distance, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchRotate(handles, angle, basePoint = null) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const base = basePoint ? (Array.isArray(basePoint) ? basePoint.join(' ') : basePoint) : '0,0';
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(command "_.rotate" (handent "${escapeLispString(handle)}") "" "${escapeLispString(base)}" "${angle}")`);
+        results.push({ handle, angle, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchScale(handles, scaleFactor, basePoint = null) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const base = basePoint ? (Array.isArray(basePoint) ? basePoint.join(' ') : basePoint) : '0,0';
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(command "_.scale" (handent "${escapeLispString(handle)}") "" "${escapeLispString(base)}" "${scaleFactor}")`);
+        results.push({ handle, scaleFactor, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchSetLinetype(handles, linetypeName) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(progn (command "_.chltype" (handent "${escapeLispString(handle)}") "${escapeLispString(linetypeName)}") (princ "ok"))`);
+        results.push({ handle, linetype: linetypeName, success: true });
+      } catch (e) { results.push({ handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchMatchProperties(sourceHandle, targetHandles) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(targetHandles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(command "_.matchprop" (handent "${escapeLispString(sourceHandle)}") (handent "${escapeLispString(handle)}"))`);
+        results.push({ from: sourceHandle, to: handle, success: true });
+      } catch (e) { results.push({ from: sourceHandle, to: handle, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchCreateGroup(name, handles) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const handleStr = handleList.map(h => `(handent "${escapeLispString(h)}")`).join(' ');
+    const result = await cad.sendCommandWithResult(`(group (list ${handleStr}))`);
+    return mcpSuccess(JSON.stringify({ name, handle: result?.trim() }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchAddToGroup(groupName, handles) {
+  try {
+    await ensureCadConnected();
+    const handleList = parseHandleList(handles);
+    const results = [];
+    for (const handle of handleList) {
+      try {
+        await cad.sendCommand(`(progn (setq grp (cdr (assoc -3 (entget (tblobjname "group" "${escapeLispString(groupName)}"))))) (entmod (append (entget (tblobjname "group" "${escapeLispString(groupName)}")) (list (cons -3 (append grp (list (handent "${escapeLispString(handle)}"))))))) )`);
+        results.push({ handle, group: groupName, success: true });
+      } catch (e) { results.push({ handle, group: groupName, error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function moveEntity(handle, dx, dy, dz = 0) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.MOVE" (handent "${escapeLispString(handle)}") "" (list ${dx} ${dy} ${dz}) "")\n`); return mcpSuccess(JSON.stringify({ handle, dx, dy, dz })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function copyEntity(handle, dx, dy, dz = 0) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.COPY" (handent "${escapeLispString(handle)}") "" (list ${dx} ${dy} ${dz}) "")\n`); return mcpSuccess(JSON.stringify({ handle, dx, dy, dz })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function rotateEntity(handle, angle, basePoint = '0,0') {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.ROTATE" (handent "${escapeLispString(handle)}") "" (list ${(basePoint||'0,0').replace(/,/g,' ')}) ${angle})\n`); return mcpSuccess(JSON.stringify({ handle, angle, basePoint })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function scaleEntity(handle, scaleFactor, basePoint = '0,0') {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.SCALE" (handent "${escapeLispString(handle)}") "" (list ${(basePoint||'0,0').replace(/,/g,' ')}) ${scaleFactor})\n`); return mcpSuccess(JSON.stringify({ handle, scaleFactor, basePoint })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function mirrorEntity(handle, startPoint, endPoint, deleteOriginal = false) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.MIRROR" (handent "${escapeLispString(handle)}") "" (list ${startPoint.replace(/,/g,' ')}) (list ${endPoint.replace(/,/g,' ')}) ${deleteOriginal ? '"_Y"' : '"_N"'})\n`); return mcpSuccess(JSON.stringify({ handle, startPoint, endPoint, deleteOriginal })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function offsetEntity(handle, distance, side) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.OFFSET" ${distance} (handent "${escapeLispString(handle)}") (list ${side.replace(/,/g,' ')}) "")\n`); return mcpSuccess(JSON.stringify({ handle, distance, side })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function arrayRectangular(handle, rows, cols, rowSpacing, colSpacing) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.ARRAY" (handent "${escapeLispString(handle)}") "" "_R" ${rows} ${cols} ${rowSpacing} ${colSpacing})\n`); return mcpSuccess(JSON.stringify({ handle, rows, cols, rowSpacing, colSpacing })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+export async function arrayPolar(handle, center, count, angle = 360) {
+    try { await ensureCadConnected(); await cad.sendCommand(`(command "_.ARRAY" (handent "${escapeLispString(handle)}") "" "_P" (list ${center.replace(/,/g,' ')}) ${count} ${angle} "")\n`); return mcpSuccess(JSON.stringify({ handle, center, count, angle })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}

package/dist/handlers/block-handlers.js

@@ -0,0 +1,214 @@
+import { cad } from '../cad.js';
+import { mcpSuccess, mcpError, escapeLispString, getNotifyProgress } from '../handler-utils.js';
+
+export async function createBlock(name, entities) {
+    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 "BLOCK" "${escapeLispString(name)}"))
+            (progn
+                (entmake
+                    (list
+                        (cons 0 "BLOCK")
+                        (cons 70 0)
+                        (cons 2 "${escapeLispString(name)}")
+                        (cons 10 (list 0 0 0))
+                    )
+                )
+                ${entities}
+                (entmake (list (cons 0 "ENDBLK")))
+                "CREATED"
+            )
+            "EXISTS"
+        )
+    )`;
+    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 insertBlock(blockName, point, scale = 1, rotation = 0) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const coords = Array.isArray(point) ? point : point.split(',').map(s => parseFloat(s.trim()));
+    if (coords.length < 2) {
+        return { content: [{ type: 'text', text: '插入点格式错误，需要 x,y 或 [x,y,z]' }], isError: true };
+    }
+    const [x, y, z = 0] = coords;
+
+    const code = `(progn
+        (vl-load-com)
+        (if (tblsearch "BLOCK" "${escapeLispString(blockName)}")
+            (progn
+                (command "._INSERT" "${escapeLispString(blockName)}" (list ${x} ${y} ${z}) ${scale} ${rotation} 0 "")
+                "INSERTED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'INSERTED' || result === '"INSERTED"') {
+            return { content: [{ type: 'text', text: `已插入块: ${blockName}` }] };
+        }
+        return { content: [{ type: 'text', text: `插入失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function getBlocks() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (setq blocks nil)
+        (while (setq blk (tblnext "BLOCK" (null blocks)))
+            (setq blocks (cons (cdr (assoc 2 blk)) blocks))
+        )
+        (reverse blocks)
+    )`;
+    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 batchGetBlockAttributes(args) {
+  if (!cad.connected) { await cad.connect(); }
+  if (!cad.connected) return mcpError('未连接 CAD');
+  try {
+    const filter = args.filter || '';
+    const blockName = args.blockName || '';
+    const lay = args.layer || '';
+    let lispFilter = '(ssget "_X" ';
+    const flist = [];
+    if (blockName) flist.push(`(cons 2 "${escapeLispString(blockName)}")`);
+    if (lay) flist.push(`(cons 8 "${escapeLispString(lay)}")`);
+    flist.push('(cons 0 "INSERT")');
+    lispFilter += `(list ${flist.join(' ')})`;
+
+    const code = `(progn
+  (vl-load-com)
+  (setq ss ${lispFilter})
+  (setq result nil)
+  (if ss
+    (progn
+      (vlax-for blk (vla-get-activeselectionset
+        (vla-get-activedocument (vlax-get-acad-object)))
+        (setq atts nil
+              atts-raw (vlax-invoke blk 'GetAttributes))
+        (if atts-raw
+          (foreach a atts-raw
+            (setq atts (cons (list (cons "tag" (vla-get-tagstring a))
+                                   (cons "value" (vla-get-textstring a))
+                                   (cons "handle" (vla-get-handle a))) atts)))
+        )
+        (setq result (cons (list (cons "handle" (vla-get-handle blk))
+                                  (cons "blockName" (vla-get-name blk))
+                                  (cons "layer" (vla-get-layer blk))
+                                  (cons "attributes" atts)) result))
+      )
+    )
+  )
+  (if result (vl-princ-to-string result) "[]")
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    return mcpSuccess(result || '[]');
+  } catch (e) {
+    return mcpError(`批量获取块属性失败: ${e.message}`);
+  }
+}
+
+export async function batchSetBlockAttributes(args) {
+  if (!cad.connected) { await cad.connect(); }
+  if (!cad.connected) return mcpError('未连接 CAD');
+  try {
+    const items = args.items || [];
+    let totalOk = 0;
+    let totalFail = 0;
+    const total = items.length;
+    for (let idx = 0; idx < total; idx++) {
+      const item = items[idx];
+      const np = getNotifyProgress();
+      if (np) np(idx + 1, total, `正在处理块 ${idx + 1}/${total}`);
+      try {
+        const handle = item.handle;
+        const attrs = item.attributes || {};
+        for (const [tag, value] of Object.entries(attrs)) {
+          await cad.sendCommandWithResult(
+            `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${escapeLispString(handle)}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq atts (vlax-invoke vobj 'GetAttributes))
+      (if atts
+        (foreach a atts
+          (if (= (vla-get-tagstring a) "${escapeLispString(tag)}")
+            (vla-put-textstring a "${escapeLispString(String(value))}")
+          )
+        )
+      )
+      (princ "ok")
+    )
+    (princ "nf")
+  )
+)`
+          );
+        }
+        totalOk++;
+      } catch (e) {
+        totalFail++;
+      }
+    }
+    const msg = `批量设置块属性完成: 成功 ${totalOk}, 失败 ${totalFail}`;
+    if (totalFail > 0) return mcpError(msg);
+    return mcpSuccess(msg);
+  } catch (e) {
+    return mcpError(`批量设置块属性失败: ${e.message}`);
+  }
+}
+
+export async function explodeBlock(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
+                (command "._EXPLODE" (ssadd ent (ssadd)))
+                "EXPLODED"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'EXPLODED' || result === '"EXPLODED"') {
+            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 };
+    }
+}