@atlisp/mcp 1.8.16 → 1.8.17

package/dist/handlers/layer-handlers.js

@@ -0,0 +1,181 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+export async function createLayer(name, color = 7, linetype = 'Continuous') {
+    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 "LAYER" "${escapeLispString(name)}"))
+            (progn
+                (entmake
+                    (list
+                        (cons 0 "LAYER")
+                        (cons 70 0)
+                        (cons 2 "${escapeLispString(name)}")
+                        (cons 62 ${color})
+                        (cons 6 "${escapeLispString(linetype)}")
+                    )
+                )
+                "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}` }] };
+        }
+        return { content: [{ type: 'text', text: `创建失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function deleteLayer(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    const code = `(progn
+        (vl-load-com)
+        (cond
+            ((eq (getvar "CLAYER") "${escapeLispString(name)}")
+             "CURRENT")
+            ((tblsearch "LAYER" "${escapeLispString(name)}")
+             (command "._LAYER" "D" "${escapeLispString(name)}" "")
+(if (not (tblsearch "LAYER" "${escapeLispString(name)}"))
+                 "DELETED"
+                 "FAILED"))
+            (t "NOTFOUND")
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'DELETED' || result === '"DELETED"') {
+            return { content: [{ type: 'text', text: `已删除图层: ${name}` }] };
+        }
+        if (result === 'CURRENT' || result === '"CURRENT"') {
+            return { content: [{ type: 'text', text: `无法删除当前图层: ${name}` }], isError: true };
+        }
+        if (result === 'NOTFOUND' || result === '"NOTFOUND"') {
+            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 setLayerProperty(name, property, value) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+
+    let propCode = '';
+    switch (property) {
+        case 'color':
+            propCode = `(command "._LAYER" "P" "${escapeLispString(name)}" "C" ${isNaN(Number(value)) ? 7 : Number(value)} "")`;
+            break;
+        case 'linetype':
+            propCode = `(command "._LAYER" "P" "${escapeLispString(name)}" "L" "${escapeLispString(value)}" "")`;
+            break;
+        case 'freeze':
+            propCode = `(command "._LAYER" "F" "${escapeLispString(name)}" "")`;
+            break;
+        case 'thaw':
+            propCode = `(command "._LAYER" "T" "${escapeLispString(name)}" "")`;
+            break;
+        case 'lock':
+            propCode = `(command "._LAYER" "LO" "${escapeLispString(name)}" "")`;
+            break;
+        case 'unlock':
+            propCode = `(command "._LAYER" "U" "${escapeLispString(name)}" "")`;
+            break;
+        default:
+            return { content: [{ type: 'text', text: `不支持的属性: ${property}` }], isError: true };
+    }
+
+    const code = `(progn
+        (vl-load-com)
+        (if (tblsearch "LAYER" "${escapeLispString(name)}")
+            (progn
+                ${propCode}
+                "OK"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置图层 ${name} 的 ${property} 为 ${value}` }] };
+        }
+        return { content: [{ type: 'text', text: `操作失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+
+export async function setCurrentLayer(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 "LAYER" "${escapeLispString(name)}")
+            (progn
+                (setvar "CLAYER" "${escapeLispString(name)}")
+                "OK"
+            )
+            "NOTFOUND"
+        )
+    )`;
+    try {
+        const result = await cad.sendCommandWithResult(code);
+        if (result === 'OK' || result === '"OK"') {
+            return { content: [{ type: 'text', text: `已设置当前图层: ${name}` }] };
+        }
+        return { content: [{ type: 'text', text: `设置失败: ${result}` }], isError: true };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true };
+    }
+}
+export async function layerIsolate(name) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand(`(command "_.LAYISO" "${escapeLispString(name)}" "")\n`); return { content: [{ type: 'text', text: `已隔离图层: ${name}` }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerUnisolate() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand('(command "_.LAYUNISO")\n'); return { content: [{ type: 'text', text: '已取消图层隔离' }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerFreezeAll() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand('(command "_.LAYER" "F" "*" "")\n'); return { content: [{ type: 'text', text: '已冻结所有图层' }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerThawAll() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand('(command "_.LAYER" "T" "*" "")\n'); return { content: [{ type: 'text', text: '已解冻所有图层' }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerLockAll() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand('(command "_.LAYER" "LO" "*" "")\n'); return { content: [{ type: 'text', text: '已锁定所有图层' }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerUnlockAll() {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand('(command "_.LAYER" "U" "*" "")\n'); return { content: [{ type: 'text', text: '已解锁所有图层' }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}
+export async function layerMerge(sourceName, targetName) {
+    if (!cad.connected) { await cad.connect(); }
+    if (!cad.connected) return { content: [{ type: 'text', text: '未连接 CAD' }], isError: true };
+    try { await cad.sendCommand(`(command "_.LAYMRG" "${escapeLispString(sourceName)}" "" "${escapeLispString(targetName)}" "Y")\n`); return { content: [{ type: 'text', text: `已将图层 ${sourceName} 合并到 ${targetName}` }] }; } catch (e) { return { content: [{ type: 'text', text: `错误: ${e.message}` }], isError: true }; }
+}

package/dist/handlers/package-handlers.js

@@ -0,0 +1,89 @@
+import { log, error as logError } from '../logger.js';
+const PACKAGES_LIST_URL = process.env.PACKAGES_LIST_URL || 'http://s3.atlisp.cn/packages-list?fmt=json';
+import { cad } from '../cad.js';
+import { MOCK_PACKAGES } from '../constants.js';
+let cachedPackages = null;
+let cachedAt = null;
+const CACHE_TTL = 10 * 60 * 1000;
+
+async function fetchPackages() {
+    const now = Date.now();
+    if (cachedPackages && cachedAt && (now - cachedAt) < CACHE_TTL) {
+        return cachedPackages;
+    }
+    try {
+        const response = await fetch(PACKAGES_LIST_URL, {
+            headers: { 'User-Agent': 'atlisp-mcp' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            cachedPackages = data;
+            cachedAt = now;
+            return data;
+        }
+    } catch (e) { logError(`Package fetch error: ${e.message}`); }
+    return cachedPackages || MOCK_PACKAGES;
+}
+
+function flattenPackages(data) {
+    if (Array.isArray(data)) return data;
+    if (data && Array.isArray(data.packages)) return data.packages;
+    return [];
+}
+
+export async function listPackages() {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) {
+        const data = await fetchPackages();
+        const items = flattenPackages(data);
+        const text = items.length
+            ? items.map(p => `${p.name} v${p.version || ''} - ${p.description || ''}`).join('\n')
+            : '无可用包';
+        return { content: [{ type: 'text', text }] };
+    }
+    const result = await cad.sendCommandWithResult('(@::package-list-in-local)');
+    if (result && result !== 'nil') return { content: [{ type: 'text', text: result }] };
+    const data = await fetchPackages();
+    const items = flattenPackages(data);
+    const text = items.length
+        ? `从注册表获取的 @lisp 包:\n${items.map(p => `${p.name} v${p.version || ''} - ${p.description || ''}`).join('\n')}`
+        : MOCK_PACKAGES.map(p => `${p.name} v${p.version} - ${p.description}`).join('\n');
+    return { content: [{ type: 'text', text: `已安装的 @lisp 包:\n${text}` }] };
+}
+
+export async function searchPackages(query) {
+    const data = await fetchPackages();
+    if (!data) {
+        return { content: [{ type: 'text', text: '无法获取包列表' }], isError: true };
+    }
+    const items = flattenPackages(data);
+    const results = [];
+    if (query) {
+        const q = query.toLowerCase();
+        for (const p of items) {
+            const name = (p.name || '').toLowerCase();
+            const desc = (p.description || '').toLowerCase();
+            if (name.includes(q) || desc.includes(q)) results.push(p);
+        }
+    } else {
+        for (const p of items) results.push(p);
+    }
+    if (results.length === 0) {
+        return { content: [{ type: 'text', text: `未找到包含 "${query}" 的包` }] };
+    }
+    return { content: [{ type: 'text', text: `搜索结果 (${results.length}):\n${results.map(p => `${p.name} v${p.version || ''} - ${p.description || ''}`).join('\n')}` }] };
+}
+
+export async function installPackage(packageName) {
+    const data = await fetchPackages();
+    const items = flattenPackages(data);
+    const pkg = items.find(p => p.name === packageName);
+    if (!pkg) {
+        return { content: [{ type: 'text', text: `错误: 包 "${packageName}" 不存在` }], isError: true };
+    }
+    if (cad.connected) {
+        await cad.sendCommand(`(@::load-module '${packageName})\n`);
+    }
+    return { content: [{ type: 'text', text: `包 "${packageName}" 安装命令已发送！` }] };
+}

package/dist/handlers/parametric-handlers.js

@@ -0,0 +1,272 @@
+import { cad } from '../cad.js';
+import { mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
+
+function esc(s) {
+  return escapeLispString(String(s || ''));
+}
+
+export async function getDynamicBlockProperties(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq result nil)
+          (foreach p dynProps
+            (setq allowed (vl-catch-all-apply 'vlax-invoke (list p 'GetAllowedValues)))
+            (if (vl-catch-all-error-p allowed) (setq allowed nil))
+            (setq result (cons (list
+              (cons "propertyName" (vla-get-propertyname p))
+              (cons "value" (vl-princ-to-string (vla-get-value p)))
+              (cons "typeCode" (vla-get-propertytype p))
+              (cons "allowedValues" (if allowed (vl-princ-to-string allowed) nil))
+            ) result))
+          )
+          (vl-princ-to-string (reverse result))
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    return mcpSuccess(result);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function setDynamicBlockProperty(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const propName = esc(args.propertyName);
+    const value = esc(args.value);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq found nil)
+          (foreach p dynProps
+            (if (= (strcase (vla-get-propertyname p)) (strcase "${propName}"))
+              (progn
+                (setq numVal (distof "${value}" 2))
+                (if numVal
+                  (vla-put-value p numVal)
+                  (vla-put-value p "${value}")
+                )
+                (setq found T)
+              )
+            )
+          )
+          (vla-update vobj)
+          (if found "ok" "PropertyNotFound")
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess(`属性 ${args.propertyName} 已设置为 ${args.value}`);
+    return mcpError(`设置失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function getBlockParameters(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq result nil)
+          (foreach p dynProps
+            (setq tc (vla-get-propertytype p))
+            (if (>= tc 3)
+              (progn
+                (setq allowed (vl-catch-all-apply 'vlax-invoke (list p 'GetAllowedValues)))
+                (if (vl-catch-all-error-p allowed) (setq allowed nil))
+                (setq result (cons (list
+                  (cons "parameterName" (vla-get-propertyname p))
+                  (cons "value" (vl-princ-to-string (vla-get-value p)))
+                  (cons "typeCode" tc)
+                  (cons "allowedValues" (if allowed (vl-princ-to-string allowed) nil))
+                ) result))
+              )
+            )
+          )
+          (vl-princ-to-string (reverse result))
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    return mcpSuccess(result);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function setBlockParameter(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const paramName = esc(args.parameterName);
+    const value = esc(args.value);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq found nil)
+          (foreach p dynProps
+            (if (and (>= (vla-get-propertytype p) 3)
+                     (= (strcase (vla-get-propertyname p)) (strcase "${paramName}")))
+              (progn
+                (setq numVal (distof "${value}" 2))
+                (if numVal
+                  (vla-put-value p numVal)
+                  (vla-put-value p "${value}")
+                )
+                (setq found T)
+              )
+            )
+          )
+          (vla-update vobj)
+          (if found "ok" "ParameterNotFound")
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess(`参数 ${args.parameterName} 已设置为 ${args.value}`);
+    return mcpError(`设置失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function listVisibilityStates(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq visProp nil)
+          (foreach p dynProps
+            (if (= (strcase (vla-get-propertyname p)) "VISIBILITY")
+              (setq visProp p)
+            )
+          )
+          (if visProp
+            (progn
+              (setq allowed (vl-catch-all-apply 'vlax-invoke (list visProp 'GetAllowedValues)))
+              (if (vl-catch-all-error-p allowed) (setq allowed nil))
+              (setq current (vl-princ-to-string (vla-get-value visProp)))
+              (setq states nil)
+              (foreach s allowed
+                (setq states (cons (list
+                  (cons "name" s)
+                  (cons "isActive" (= (strcase (vl-princ-to-string s)) (strcase current)))
+                ) states))
+              )
+              (vl-princ-to-string (reverse states))
+            )
+            "NoVisibilityProperty"
+          )
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    return mcpSuccess(result);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}
+
+export async function setVisibilityState(args) {
+  try {
+    if (!cad.connected) await cad.connect();
+    if (!cad.connected) return mcpError('未连接 CAD');
+    const handle = esc(args.blockHandle);
+    const stateName = esc(args.stateName);
+    const code = `(progn
+  (vl-load-com)
+  (if (setq ent (handent "${handle}"))
+    (progn
+      (setq vobj (vlax-ename->vla-object ent))
+      (setq dynProps (vl-catch-all-apply 'vlax-invoke (list vobj 'GetDynamicBlockProperties)))
+      (if (vl-catch-all-error-p dynProps)
+        "NotDynamicBlock"
+        (progn
+          (setq visProp nil)
+          (foreach p dynProps
+            (if (= (strcase (vla-get-propertyname p)) "VISIBILITY")
+              (setq visProp p)
+            )
+          )
+          (if visProp
+            (progn
+              (vla-put-value visProp "${stateName}")
+              (vla-update vobj)
+              "ok"
+            )
+            "NoVisibilityProperty"
+          )
+        )
+      )
+    )
+    "EntityNotFound"
+  )
+)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (result === 'ok') return mcpSuccess(`可见性状态已切换为: ${args.stateName}`);
+    return mcpError(`设置失败: ${result}`);
+  } catch (e) {
+    return mcpError(`错误: ${e.message}`);
+  }
+}

package/dist/handlers/pdf-annotation-handlers.js

@@ -0,0 +1,117 @@
+import { cad } from '../cad.js';
+import { log } from '../logger.js';
+import { mcpSuccess, mcpError, ensureCadConnected, escapeLispString } from '../handler-utils.js';
+
+export async function attachPdf(point, pdfPath, scale = 1, rotation = 0) {
+  try { await ensureCadConnected(); const pt = Array.isArray(point) ? point.join(' ') : point; await cad.sendCommand(`(command "_.pdfattach" "${escapeLispString(pdfPath)}" "${escapeLispString(pt)}" "${scale}" "${rotation}")`); return mcpSuccess(JSON.stringify({ pdfPath, point: pt, scale, rotation })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function listAttachedPdfs() {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq i -1 pdfs nil ss (ssget "X" (list (cons 0 "PDFREFERENCE"))))
+  (if ss (repeat (sslength ss) (setq ent (ssname ss (setq i (1+ i))) pdfs (cons (cdr (assoc -1 (entget ent))) pdfs))))
+  (princ (vl-prin1-to-string (reverse pdfs)))
+)`);
+    let handles = [];
+    if (result && result !== 'nil') { try { handles = JSON.parse(result); } catch { handles = []; } }
+    return mcpSuccess(JSON.stringify({ handles, count: handles.length }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function reloadPdf(pdfHandle) {
+  try { await ensureCadConnected(); const result = await cad.sendCommandWithResult(`(progn (command "_.pdfreload" (handent "${escapeLispString(pdfHandle)}")) (princ "reloaded"))`); return mcpSuccess(JSON.stringify({ handle: pdfHandle, reloaded: result?.includes('reloaded') })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function detachPdf(pdfHandle) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(entdel (handent "${escapeLispString(pdfHandle)}"))`); return mcpSuccess(JSON.stringify({ handle: pdfHandle, detached: true })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function getPdfInfo(pdfHandle) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (setq ent (handent "${escapeLispString(pdfHandle)}"))
+  (if ent (princ (vl-prin1-to-string (list (cons "path" (cdr (assoc 1 (entget ent)))) (cons "name" (cdr (assoc 2 (entget ent))))))) (princ "nil"))
+)`);
+    let info = {};
+    if (result && result !== 'nil') { try { info = JSON.parse(result); } catch { info = {}; } }
+    return mcpSuccess(JSON.stringify({ handle: pdfHandle, info }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createDgnUnderlay(dgnPath, point, scale = 1) {
+  try { await ensureCadConnected(); const pt = Array.isArray(point) ? point.join(' ') : point; await cad.sendCommand(`(command "_.dgnattach" "${escapeLispString(dgnPath)}" "${escapeLispString(pt)}" "${scale}")`); return mcpSuccess(JSON.stringify({ dgnPath, point: pt, scale })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createDwfUnderlay(dwfPath, point, scale = 1) {
+  try { await ensureCadConnected(); const pt = Array.isArray(point) ? point.join(' ') : point; await cad.sendCommand(`(command "_.dwfattach" "${escapeLispString(dwfPath)}" "${escapeLispString(pt)}" "${scale}")`); return mcpSuccess(JSON.stringify({ dwfPath, point: pt, scale })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function importDxf(dxfPath, explode = false) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.dxfin" "${escapeLispString(dxfPath)}" ${explode ? '"explode"' : ''})`); return mcpSuccess(JSON.stringify({ dxfPath, explode })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function importDgn(sourceFile, targetFile = '') {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.dgnin" "${escapeLispString(sourceFile)}" "${escapeLispString(targetFile)}")`); return mcpSuccess(JSON.stringify({ sourceFile, targetFile })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function exportDgn(filePath) {
+  try { await ensureCadConnected(); await cad.sendCommand(`(command "_.dgnout" "${escapeLispString(filePath)}")`); return mcpSuccess(JSON.stringify({ filePath })); } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function createHyperlink(handle, url, description = '') {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn
+    (vla-put-hyperlinks (vlax-ename->vla-object ent) (vlax-add (vla-get-hyperlinks (vlax-ename->vla-object ent)) "${escapeLispString(url)}" "${escapeLispString(description)}"))
+    (princ "added")) (princ "nil"))
+)`);
+    return mcpSuccess(JSON.stringify({ handle, url, description, added: result?.includes('added') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function removeHyperlink(handle) {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (vl-load-com)
+  (setq ent (handent "${escapeLispString(handle)}"))
+  (if ent (progn (vla-clear (vla-get-hyperlinks (vlax-ename->vla-object ent))) (princ "removed")) (princ "nil"))
+)`);
+    return mcpSuccess(JSON.stringify({ handle, removed: result?.includes('removed') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function batchAttachPdfs(pdfFiles, basePoint, spacing = 0, direction = 'x') {
+  try {
+    await ensureCadConnected();
+    const results = [];
+    const pt = Array.isArray(basePoint) ? basePoint.join(' ') : basePoint;
+    for (let i = 0; i < pdfFiles.length; i++) {
+      try {
+        const offsetX = direction === 'x' ? 0 : spacing * i;
+        const offsetY = direction === 'y' ? 0 : spacing * i;
+        await cad.sendCommand(`(command "_.pdfattach" "${escapeLispString(pdfFiles[i])}" (getvar "viewctr") "1" "0")`);
+        if (spacing > 0 && i > 0) { await cad.sendCommand(`(command "_.move" "l" "" (getvar "viewctr") (list ${offsetX} ${offsetY} 0))`); }
+        results.push({ file: pdfFiles[i], success: true });
+      } catch (e) { results.push({ file: pdfFiles[i], error: e.message, success: false }); }
+    }
+    return mcpSuccess(JSON.stringify(results));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}
+
+export async function savePdfLayout(layoutName, outputPath, plotDevice = 'DWG to PDF.pc3', paperSize = 'A4') {
+  try {
+    await ensureCadConnected();
+    const result = await cad.sendCommandWithResult(`(progn
+  (command "_.plot" "y" "${escapeLispString(layoutName)}" "${escapeLispString(plotDevice)}" "${escapeLispString(paperSize)}" "Landscape" "n" "n" "n" "n" "n" "${escapeLispString(outputPath)}")
+  (princ "saved")
+)`);
+    return mcpSuccess(JSON.stringify({ layoutName, outputPath, saved: result?.includes('saved') || result?.includes('配置') }));
+  } catch (e) { return mcpError(`错误: ${e.message}`); }
+}

package/dist/handlers/prompt-handlers.js

@@ -0,0 +1,9 @@
+import { listPrompts as loaderList, getPrompt as loaderGet } from '../prompts/loader.js';
+
+export async function listPrompts() {
+  return loaderList();
+}
+
+export async function getPrompt(name, arguments_ = {}) {
+  return loaderGet(name, arguments_);
+}