@atlisp/mcp 1.3.4 → 1.3.7

package/dist/atlisp-mcp.js

@@ -34,8 +34,7 @@ var SessionTransport = class {
     this._started = true;
   }
   async send(message) {
-    if (this._closed)
-      return;
+    if (this._closed) return;
     if (this._pendingRequest) {
       const { resolve, reject, timeout } = this._pendingRequest;
       clearTimeout(timeout);
@@ -44,8 +43,7 @@ var SessionTransport = class {
     }
   }
   async close() {
-    if (this._closed)
-      return;
+    if (this._closed) return;
     this._closed = true;
     if (this._pendingRequest) {
       const { reject, timeout } = this._pendingRequest;
@@ -212,8 +210,7 @@ function setupStdoutHandler(w) {
       const lines = buffer.split("\n");
       buffer = lines.pop() || "";
       for (const line of lines) {
-        if (!line.trim())
-          continue;
+        if (!line.trim()) continue;
         try {
           const result = JSON.parse(line);
           const rid = result.requestId;
@@ -238,8 +235,7 @@ function setupStdoutHandler(w) {
 }
 function getWorker() {
   if (!worker || !worker.connected) {
-    if (worker)
-      worker.kill();
+    if (worker) worker.kill();
     worker = spawn("node", [workerPath], {
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -248,8 +244,7 @@ function getWorker() {
     const w = worker;
     w.on("exit", (code) => {
       console.error("worker exited:", code);
-      if (w !== worker)
-        return;
+      if (w !== worker) return;
       w.connected = false;
       for (const [id, { reject, timeout }] of pendingRequests) {
         clearTimeout(timeout);
@@ -268,8 +263,7 @@ function getWorker() {
   return worker;
 }
 function startHeartbeat() {
-  if (heartbeatTimer)
-    clearInterval(heartbeatTimer);
+  if (heartbeatTimer) clearInterval(heartbeatTimer);
   heartbeatTimer = setInterval(async () => {
     try {
       const result = await sendMessage({ type: "ping" });
@@ -314,8 +308,7 @@ var CadConnection = class {
     return process.platform === "win32";
   }
   async connect() {
-    if (!this.isAvailable())
-      return false;
+    if (!this.isAvailable()) return false;
     try {
       const result = await sendMessage({ type: "connect" });
       if (result && result.success) {
@@ -331,16 +324,13 @@ var CadConnection = class {
     return false;
   }
   async sendCommand(code) {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     const result = await sendMessage({ type: "send", code, platform: _platform });
-    if (result.success)
-      return true;
+    if (result.success) return true;
     throw new Error(result.error || "\u53D1\u9001\u5931\u8D25");
   }
   async sendCommandWithResult(code, encoding = null) {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     const result = await sendMessage({ type: "sendResult", code, platform: _platform, encoding: encoding || "" });
     if (result.success) {
       return result.result || "";
@@ -354,8 +344,7 @@ var CadConnection = class {
     return this.product;
   }
   async isBusy() {
-    if (!this.connected)
-      return false;
+    if (!this.connected) return false;
     try {
       const result = await sendMessage({ type: "isBusy", platform: _platform });
       return result && result.isBusy;
@@ -364,8 +353,7 @@ var CadConnection = class {
     }
   }
   async hasDoc() {
-    if (!this.connected)
-      return { hasDoc: false, docCount: 0 };
+    if (!this.connected) return { hasDoc: false, docCount: 0 };
     try {
       const result = await sendMessage({ type: "hasdoc", platform: _platform });
       return result || { hasDoc: false, docCount: 0 };
@@ -374,8 +362,7 @@ var CadConnection = class {
     }
   }
   async newDoc() {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "newdoc", platform: _platform });
       return result && result.success;
@@ -384,8 +371,7 @@ var CadConnection = class {
     }
   }
   async bringToFront() {
-    if (!this.connected)
-      throw new Error("\u672A\u8FDE\u63A5 CAD");
+    if (!this.connected) throw new Error("\u672A\u8FDE\u63A5 CAD");
     try {
       const result = await sendMessage({ type: "bringToFront", platform: _platform });
       return result && result.success;
@@ -394,8 +380,7 @@ var CadConnection = class {
     }
   }
   async getInfo() {
-    if (!this.connected)
-      return "CAD \u672A\u8FDE\u63A5";
+    if (!this.connected) return "CAD \u672A\u8FDE\u63A5";
     return `Platform: ${this.product}, Version: ${this.version}, Status: Connected`;
   }
   async disconnect() {
@@ -469,16 +454,18 @@ async function evalLisp(code, withResult = false, encoding = null) {
   if (!cad.connected) {
     return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   }
+  const trimmed = (code || "").trim();
+  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   try {
     if (withResult) {
-      const result = await cad.sendCommandWithResult(code, encoding);
+      const result = await cad.sendCommandWithResult(trimmed, encoding);
       if (result !== null) {
         return { content: [{ type: "text", text: result }] };
       }
       return { content: [{ type: "text", text: "\u6267\u884C\u5931\u8D25\u6216\u65E0\u8FD4\u56DE\u503C" }], isError: true };
     } else {
-      await cad.sendCommand(code + "\n");
-      return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4: ${code}` }] };
+      await cad.sendCommand(trimmed + "\n");
+      return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4` }] };
     }
   } catch (e) {
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
@@ -488,23 +475,22 @@ async function getCadInfo() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
+  if (!cad.connected) return { content: [{ type: "text", text: "CAD \u672A\u8FDE\u63A5" }] };
   const info = await cad.getInfo();
   return { content: [{ type: "text", text: info }] };
 }
 async function atCommand(command) {
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
-  await cad.sendCommand(command + "\n");
-  return { content: [{ type: "text", text: `\u5DF2\u53D1\u9001\u547D\u4EE4: ${command}` }] };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u8BF7\u5148\u8FDE\u63A5 CAD" }], isError: true };
+  const trimmed = (command || "").trim();
+  if (!trimmed) return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
+  await cad.sendCommand(trimmed + "\n");
+  return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001\u547D\u4EE4" }] };
 }
 async function newDocument() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.newDoc();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5728 CAD \u4E2D\u65B0\u5EFA\u7A7A\u767D\u6587\u6863" }] };
@@ -515,8 +501,7 @@ async function bringToFront() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.bringToFront();
   if (result) {
     return { content: [{ type: "text", text: "\u5DF2\u5C06 CAD \u7A97\u53E3\u5207\u6362\u5230\u524D\u53F0" }] };
@@ -527,8 +512,7 @@ async function installAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const installCode = `(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o'send)(v o'WaitforResponse 1000)(e(r(vlax-get-property o'ResponseText))))`;
   await cad.sendCommand(installCode + "\n");
   return { content: [{ type: "text", text: "\u5DF2\u53D1\u9001 @lisp \u5B89\u88C5\u4EE3\u7801\u5230 CAD" }] };
@@ -537,12 +521,10 @@ async function listFunctionsInCad() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   try {
     const result = await cad.sendCommandWithResult("(atoms-family 0)", null);
-    if (result)
-      return { content: [{ type: "text", text: result }] };
+    if (result) return { content: [{ type: "text", text: result }] };
     return { content: [{ type: "text", text: "CAD \u51FD\u6570\u5217\u8868\u4E3A\u7A7A" }] };
   } catch (e) {
     return { content: [{ type: "text", text: `\u9519\u8BEF: ${e.message}` }], isError: true };
@@ -552,8 +534,7 @@ async function initAtlisp() {
   if (!cad.connected) {
     await cad.connect();
   }
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const code = `(if (null @::load-module)
 	   (progn
 	     (vl-load-com)
@@ -593,13 +574,10 @@ async function fetchPackages() {
   return null;
 }
 async function listPackages() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { content: [{ type: "text", text: "\u672A\u8FDE\u63A5 CAD" }], isError: true };
   const result = await cad.sendCommandWithResult("(@::package-list-in-local)");
-  if (result && result !== "nil")
-    return { content: [{ type: "text", text: result }] };
+  if (result && result !== "nil") return { content: [{ type: "text", text: result }] };
   const packages = MOCK_PACKAGES.map((p) => `${p.name} v${p.version} - ${p.description}`);
   return { content: [{ type: "text", text: `\u5DF2\u5B89\u88C5\u7684 @lisp \u5305:
 ${packages.join("\n")}` }] };
@@ -616,12 +594,10 @@ async function searchPackages(query) {
     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);
+      if (name.includes(q) || desc.includes(q)) results.push(p);
     }
   } else {
-    for (const p of items)
-      results.push(p);
+    for (const p of items) results.push(p);
   }
   if (results.length === 0) {
     return { content: [{ type: "text", text: `\u672A\u627E\u5230\u5305\u542B "${query}" \u7684\u5305` }] };
@@ -663,8 +639,7 @@ async function getFunctionUsage(funcName, packageName) {
         const data = await response.json();
         const funcs = Object.values(data.all_functions || {});
         const func = funcs.find((f2) => f2.name === funcName || f2.name === `${packageName}:${funcName}`);
-        if (func)
-          results.push(func);
+        if (func) results.push(func);
       }
     } catch (e) {
       log(`function-handlers fetch error: ${e.message}`);
@@ -675,8 +650,7 @@ async function getFunctionUsage(funcName, packageName) {
         const raw = await fs2.readFile(path3.join(FUNCTIONS_DIR, file), "utf-8");
         const data = JSON.parse(raw);
         const func = data.functions?.find((f2) => f2.name === funcName);
-        if (func)
-          results.push(func);
+        if (func) results.push(func);
       }
     }
     if (results.length === 0) {
@@ -757,14 +731,11 @@ function setCache(key, data) {
   resourceCache.set(key, { data, timestamp: Date.now() });
 }
 function parseLispList(str) {
-  if (!str || typeof str !== "string")
-    return null;
+  if (!str || typeof str !== "string") return null;
   const trimmed = str.trim();
-  if (!trimmed.startsWith("(") || !trimmed.endsWith(")"))
-    return null;
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) return null;
   const content = trimmed.slice(1, -1).trim();
-  if (!content)
-    return [];
+  if (!content) return [];
   const result = [];
   let depth = 0;
   let current = "";
@@ -806,21 +777,15 @@ function parseLispList(str) {
     }
     current += ch;
   }
-  if (current.trim())
-    result.push(current.trim());
+  if (current.trim()) result.push(current.trim());
   return result.map((item) => {
     const t = item.trim();
-    if (t === "nil")
-      return null;
-    if (t === "t")
-      return true;
-    if (t === "T")
-      return true;
+    if (t === "nil") return null;
+    if (t === "t") return true;
+    if (t === "T") return true;
     const num = Number(t);
-    if (!isNaN(num) && t !== "")
-      return num;
-    if (t.startsWith('"') && t.endsWith('"'))
-      return t.slice(1, -1);
+    if (!isNaN(num) && t !== "") return num;
+    if (t.startsWith('"') && t.endsWith('"')) return t.slice(1, -1);
     return t;
   });
 }
@@ -835,16 +800,14 @@ var RESOURCES = [
 ];
 function parseQuery(uri) {
   const qIdx = uri.indexOf("?");
-  if (qIdx === -1)
-    return { base: uri, params: {} };
+  if (qIdx === -1) return { base: uri, params: {} };
   const base = uri.substring(0, qIdx);
   const params = {};
   uri.substring(qIdx + 1).split("&").forEach((p) => {
     const eqIdx = p.indexOf("=");
     const k = eqIdx === -1 ? p : p.substring(0, eqIdx);
     const v = eqIdx === -1 ? "" : p.substring(eqIdx + 1);
-    if (k)
-      params[k] = decodeURIComponent(v);
+    if (k) params[k] = decodeURIComponent(v);
   });
   return { base, params };
 }
@@ -880,8 +843,7 @@ async function readResource(uri) {
 }
 async function getCadInfo2() {
   const cached = getCached("cad:info");
-  if (cached)
-    return cached;
+  if (cached) return cached;
   if (!cad.connected) {
     await cad.connect();
   }
@@ -908,12 +870,9 @@ async function getCadInfo2() {
 async function getLayers(filterName = null) {
   const cacheKey = filterName ? `layers:${filterName}` : "layers:all";
   const cached = getCached(cacheKey);
-  if (cached)
-    return cached;
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return [];
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return [];
   try {
     const code = filterName ? `(tblnext "LAYER" T)` : `(progn (setq res nil)(while (setq e (tblnext "LAYER" (null res)))(setq res (cons (list (cdr (assoc 2 e)) (cdr (assoc 62 e)) (cdr (assoc 70 e))) res))) (reverse res))`;
     const result = await cad.sendCommandWithResult(code);
@@ -960,10 +919,8 @@ async function getLayers(filterName = null) {
 async function getEntities(filterType = null) {
   const cacheKey = filterType ? `entities:${filterType}` : "entities:all";
   const cached = getCached(cacheKey);
-  if (cached)
-    return cached;
-  if (!cad.connected)
-    await cad.connect();
+  if (cached) return cached;
+  if (!cad.connected) await cad.connect();
   if (!cad.connected) {
     const result = { total: 0, byType: {} };
     setCache(cacheKey, result);
@@ -1017,10 +974,8 @@ async function getEntities(filterType = null) {
   }
 }
 async function getDwgName() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { name: null };
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { name: null };
   try {
     const code = `(vl-princ-to-string (getvar "dwgname"))`;
     const name = await cad.sendCommandWithResult(code);
@@ -1030,10 +985,8 @@ async function getDwgName() {
   }
 }
 async function getDwgPath() {
-  if (!cad.connected)
-    await cad.connect();
-  if (!cad.connected)
-    return { path: null, name: null };
+  if (!cad.connected) await cad.connect();
+  if (!cad.connected) return { path: null, name: null };
   try {
     const code = `(progn
           (setq prefix (vl-princ-to-string (getvar "dwgprefix")))
@@ -1051,8 +1004,7 @@ async function getDwgPath() {
     }
     if (!parsed) {
       const listResult = parseLispList(result);
-      if (listResult && listResult.length >= 2)
-        parsed = listResult;
+      if (listResult && listResult.length >= 2) parsed = listResult;
     }
     if (parsed && Array.isArray(parsed) && parsed.length >= 2) {
       return { path: String(parsed[0]), name: String(parsed[1]) };
@@ -1127,6 +1079,92 @@ var PROMPTS = [
     arguments: [
       { name: "format", description: "\u5BFC\u51FA\u683C\u5F0F (json/list)", required: false }
     ]
+  },
+  {
+    name: "manage-layers",
+    description: "\u56FE\u5C42\u7BA1\u7406\uFF1A\u521B\u5EFA\u3001\u51BB\u7ED3\u3001\u9501\u5B9A\u3001\u5220\u9664\u56FE\u5C42",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/freeze/lock/off/make/delete)", required: true },
+      { name: "layers", description: "\u56FE\u5C42\u540D\uFF0C\u591A\u4E2A\u7528\u9017\u53F7\u5206\u9694", required: false },
+      { name: "color", description: '\u56FE\u5C42\u989C\u8272 (ACI\u53F7\u6216RGB\u5982 "1,2,3")', required: false }
+    ]
+  },
+  {
+    name: "manage-blocks",
+    description: "\u5757\u64CD\u4F5C\uFF1A\u63D2\u5165\u5757\u3001\u5217\u51FA\u5757\u3001\u83B7\u53D6/\u8BBE\u7F6E\u5C5E\u6027",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C\u7C7B\u578B (list/insert/attributes/dynprops)", required: true },
+      { name: "blockName", description: "\u5757\u540D", required: false },
+      { name: "insertPoint", description: '\u63D2\u5165\u70B9 "x,y"', required: false },
+      { name: "scale", description: "\u7F29\u653E\u6BD4\u4F8B", required: false }
+    ]
+  },
+  {
+    name: "curve-analysis",
+    description: "\u66F2\u7EBF\u5206\u6790\uFF1A\u4EA4\u70B9\u3001\u6700\u8FD1\u70B9\u3001\u5B50\u6BB5\u3001\u7F13\u51B2\u533A",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (inters/subsegments/closestpoint/join)", required: true },
+      { name: "distance", description: "\u8FDE\u63A5\u5BB9\u5DEE/\u504F\u79FB\u8DDD\u79BB", required: false }
+    ]
+  },
+  {
+    name: "geometry-calc",
+    description: "\u51E0\u4F55\u8BA1\u7B97\uFF1A\u51F8\u5305\u3001\u70B9\u5230\u7EBF\u8DDD\u79BB\u3001\u9762\u5185\u6D4B\u8BD5\u3001\u53D8\u6362",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (convexhull/dist-point-line/in-curve-p/transform/centroid)", required: true },
+      { name: "points", description: '\u70B9\u96C6 "x1,y1;x2,y2;..."', required: false }
+    ]
+  },
+  {
+    name: "text-process",
+    description: "\u6587\u672C\u5904\u7406\uFF1AMTEXT\u89E3\u6790\u3001Markdown\u8F6CMTEXT\u3001\u53BB\u683C\u5F0F",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (parse-mtext/remove-fmt/from-markdown/mtext2text)", required: true },
+      { name: "markdown", description: "Markdown\u6587\u672C\uFF08from-markdown\u64CD\u4F5C\u65F6\u7528\uFF09", required: false }
+    ]
+  },
+  {
+    name: "pickset-filter",
+    description: "\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A\u8FC7\u6EE4\u3001\u8F6C\u6362\u3001\u6279\u91CF\u64CD\u4F5C",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (by-layer/by-type/by-box/erase/zoom)", required: true },
+      { name: "dxfType", description: 'DXF\u7C7B\u578B "LINE, CIRCLE, LWPOLYLINE, INSERT, TEXT"', required: false },
+      { name: "layerName", description: "\u56FE\u5C42\u540D", required: false }
+    ]
+  },
+  {
+    name: "color-convert",
+    description: "\u989C\u8272\u8F6C\u6362\uFF1AACI/RGB/TrueColor/CSS\u4E92\u8F6C",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (aci2rgb/rgb2css/truecolor2rgb/rgb2truecolor)", required: true },
+      { name: "value", description: "\u989C\u8272\u503C", required: true }
+    ]
+  },
+  {
+    name: "json-exchange",
+    description: "JSON\u6570\u636E\u4EA4\u6362\uFF1A\u4ECE\u5B57\u7B26\u4E32\u89E3\u6790JSON alist\uFF0C\u4ECEalist\u751F\u6210JSON",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (encode/decode)", required: true },
+      { name: "data", description: "JSON\u5B57\u7B26\u4E32\u6216Lisp alist\u6587\u672C", required: true }
+    ]
+  },
+  {
+    name: "excel-report",
+    description: "Excel\u62A5\u8868\uFF1A\u5BFC\u51FACAD\u5B9E\u4F53\u6570\u636E\u5230Excel",
+    arguments: [
+      { name: "visible", description: "\u662F\u5426\u663E\u793AExcel\u7A97\u53E3 (true/false)", required: false },
+      { name: "savePath", description: "\u4FDD\u5B58\u8DEF\u5F84\uFF0C\u4E0D\u586B\u5219\u4E0D\u4FDD\u5B58", required: false }
+    ]
+  },
+  {
+    name: "string-process",
+    description: "\u5B57\u7B26\u4E32\u5904\u7406\uFF1A\u683C\u5F0F\u5316\u3001\u62C6\u5206\u3001\u66FF\u6362\u3001\u6B63\u5219",
+    arguments: [
+      { name: "action", description: "\u64CD\u4F5C (format/split/subst-all/regexp/trim/number2chinese)", required: true },
+      { name: "input", description: "\u8F93\u5165\u5B57\u7B26\u4E32", required: true },
+      { name: "arg1", description: "\u53C2\u65701\uFF08\u683C\u5F0F\u53C2\u6570/\u5206\u9694\u7B26/\u65E7\u4E32\uFF09", required: false },
+      { name: "arg2", description: "\u53C2\u65702\uFF08\u65B0\u4E32/\u6B63\u5219\u6A21\u5F0F\uFF09", required: false }
+    ]
   }
 ];
 async function listPrompts() {
@@ -1146,6 +1184,26 @@ async function getPrompt(name, arguments_ = {}) {
       return generateDimensionPrompt(arguments_);
     case "export-entities":
       return generateExportPrompt(arguments_);
+    case "manage-layers":
+      return generateManageLayersPrompt(arguments_);
+    case "manage-blocks":
+      return generateManageBlocksPrompt(arguments_);
+    case "curve-analysis":
+      return generateCurveAnalysisPrompt(arguments_);
+    case "geometry-calc":
+      return generateGeometryCalcPrompt(arguments_);
+    case "text-process":
+      return generateTextProcessPrompt(arguments_);
+    case "pickset-filter":
+      return generatePicksetFilterPrompt(arguments_);
+    case "color-convert":
+      return generateColorConvertPrompt(arguments_);
+    case "json-exchange":
+      return generateJsonExchangePrompt(arguments_);
+    case "excel-report":
+      return generateExcelReportPrompt(arguments_);
+    case "string-process":
+      return generateStringProcessPrompt(arguments_);
     default:
       throw new Error(`Unknown prompt: ${name}`);
   }
@@ -1256,14 +1314,10 @@ ${generateSuggestions(entities, layers)}`
 }
 function generateSuggestions(entities, layers) {
   const suggestions = [];
-  if (entities.total > 1e3)
-    suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
-  if (layers.length > 20)
-    suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
-  if (entities.byType.LINE && entities.byType.LINE > 500)
-    suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
-  if (!entities.byType.DIMENSION)
-    suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
+  if (entities.total > 1e3) suggestions.push("- \u56FE\u7EB8\u5B9E\u4F53\u8F83\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528\u56FE\u5C42\u5206\u7C7B\u7BA1\u7406");
+  if (layers.length > 20) suggestions.push("- \u56FE\u5C42\u8F83\u591A\uFF0C\u5EFA\u8BAE\u6E05\u7406\u672A\u4F7F\u7528\u7684\u56FE\u5C42");
+  if (entities.byType.LINE && entities.byType.LINE > 500) suggestions.push("- \u7EBF\u6761\u8F83\u591A\uFF0C\u53EF\u8003\u8651\u4F7F\u7528 BLOCK \u51CF\u5C11\u5B9E\u4F53\u6570\u91CF");
+  if (!entities.byType.DIMENSION) suggestions.push("- \u672A\u53D1\u73B0\u5C3A\u5BF8\u6807\u6CE8\uFF0C\u5EFA\u8BAE\u6DFB\u52A0\u6807\u6CE8");
   return suggestions.length ? suggestions.join("\n") : "- \u56FE\u7EB8\u7ED3\u6784\u826F\u597D";
 }
 async function generateBatchLinesPrompt(args) {
@@ -1367,6 +1421,418 @@ ${code}
     }]
   };
 }
+async function generateManageLayersPrompt(args) {
+  const { action = "list", layers = "", color = "" } = args;
+  const layerList = layers ? layers.split(/[,， ]+/) : [];
+  const codeMap = {
+    list: `(layer:list)`,
+    make: `(layer:make "${layerList[0] || "NEW-LAYER"}" ${color || "7"} "Continuous" 0)`,
+    freeze: `(mapcar (function (lambda (x) (layer:freeze x 1))) '${JSON.stringify(layerList.length ? layerList : ["0"])})`,
+    lock: `(mapcar (function (lambda (x) (layer:lock x 1))) '${JSON.stringify(layerList.length ? layerList : ["0"])})`,
+    off: `(mapcar (function (lambda (x) (layer:off x))) '${JSON.stringify(layerList.length ? layerList : ["0"])})`,
+    delete: `(mapcar (function (lambda (x) (layer:delete x))) '${JSON.stringify(layerList.length ? layerList : ["0"]).replace(/"/g, '"')})`
+  };
+  const code = codeMap[action] || codeMap.list;
+  const descMap = {
+    list: "\u5217\u51FA\u6240\u6709\u56FE\u5C42",
+    make: `\u521B\u5EFA\u56FE\u5C42 ${layerList[0] || "NEW-LAYER"}\uFF0C\u989C\u8272 ${color || "7"}`,
+    freeze: `\u51BB\u7ED3\u56FE\u5C42: ${layerList.join(", ") || "\u672A\u6307\u5B9A"}`,
+    lock: `\u9501\u5B9A\u56FE\u5C42: ${layerList.join(", ") || "\u672A\u6307\u5B9A"}`,
+    off: `\u5173\u95ED\u56FE\u5C42: ${layerList.join(", ") || "\u672A\u6307\u5B9A"}`,
+    delete: `\u5220\u9664\u56FE\u5C42: ${layerList.join(", ") || "\u672A\u6307\u5B9A"}`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `${descMap[action] || descMap.list}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateManageBlocksPrompt(args) {
+  const { action = "list", blockName = "\u5757\u540D", insertPoint = "0,0", scale = "1" } = args;
+  const pt = insertPoint.split(",").map(Number);
+  const codeMap = {
+    list: `(block:list)`,
+    insert: `(block:insert "${blockName}" "${blockName}" (list ${pt[0] || 0} ${pt[1] || 0}) 0 ${scale})`,
+    attributes: `(block:get-attributes (car (pickset:to-list (ssget "_X" (list (cons 2 "${blockName}"))))))`,
+    dynprops: `(block:get-dynamic-properties (car (pickset:to-list (ssget "_X" (list (cons 2 "${blockName}"))))))`
+  };
+  const code = codeMap[action] || codeMap.list;
+  const descMap = {
+    list: "\u5217\u51FA\u5F53\u524D\u56FE\u7EB8\u4E2D\u6240\u6709\u5757\u5B9A\u4E49",
+    insert: `\u63D2\u5165\u5757 "${blockName}" \u5230\u70B9 (${pt[0] || 0}, ${pt[1] || 0})\uFF0C\u6BD4\u4F8B ${scale}`,
+    attributes: `\u83B7\u53D6\u5757 "${blockName}" \u7684\u5C5E\u6027\u6807\u7B7E-\u503C\u5217\u8868`,
+    dynprops: `\u83B7\u53D6\u52A8\u6001\u5757 "${blockName}" \u7684\u53EF\u8C03\u5C5E\u6027`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `${descMap[action] || descMap.list}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateCurveAnalysisPrompt(args) {
+  const { action = "inters", distance = "100" } = args;
+  const codeMap = {
+    inters: `(progn
+  (setq ss (ssget "_X" (list (cons 0 "LWPOLYLINE,LINE,ARC,CIRCLE"))))
+  (if (and ss (>= (sslength ss) 2))
+    (progn
+      (setq elst (pickset:to-list ss))
+      (setq e1 (car elst) e2 (cadr elst))
+      (curve:inters e1 e2 0)
+    )
+  )
+)`,
+    subsegments: `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "LWPOLYLINE"))))))
+  (if e (curve:subsegments e))
+)`,
+    closestpoint: `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "LWPOLYLINE,LINE,ARC,CIRCLE"))))))
+  (if e (curve:pickclosepointto e (getpoint "\\n\u9009\u62E9\u53C2\u8003\u70B9: ")))
+)`,
+    join: `(progn
+  (setq ss (ssget (list (cons 0 "LINE,LWPOLYLINE"))))
+  (if ss (curve:join (pickset:to-list ss) ${distance}))
+)`
+  };
+  const code = codeMap[action] || codeMap.inters;
+  const descMap = {
+    inters: "\u9009\u62E9\u524D\u4E24\u4E2A\u66F2\u7EBF\u5BF9\u8C61\uFF0C\u8BA1\u7B97\u5176\u4EA4\u70B9\uFF08\u53EF\u6307\u5B9A LWPOLYLINE, LINE, ARC, CIRCLE\uFF09",
+    subsegments: "\u9009\u62E9\u4E00\u4E2ALWPOLYLINE\uFF0C\u8FD4\u56DE\u5176\u5B50\u6BB5\u6570",
+    closestpoint: "\u9009\u62E9\u4E00\u4E2A\u66F2\u7EBF\u5BF9\u8C61\uFF0C\u7136\u540E\u62FE\u53D6\u4E00\u4E2A\u70B9\uFF0C\u8FD4\u56DE\u66F2\u7EBF\u4E0A\u79BB\u8BE5\u70B9\u6700\u8FD1\u7684\u70B9",
+    join: "\u9009\u62E9LINE/LWPOLYLINE\u7EBF\u6BB5\uFF0C\u7528 PEDIT Join \u5408\u5E76\uFF0C\u5BB9\u5DEE\u8DDD\u79BB=" + distance
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u66F2\u7EBF\u64CD\u4F5C\uFF1A${descMap[action] || descMap.inters}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u63D0\u793A\uFF1A\u786E\u4FDD CAD \u4E2D\u5DF2\u6709\u5BF9\u5E94\u56FE\u5F62\u5BF9\u8C61\u3002`
+      }
+    }]
+  };
+}
+async function generateGeometryCalcPrompt(args) {
+  const { action = "centroid", points = "0,0;100,0;100,100;0,100" } = args;
+  const ptList = points.split(";").map((p) => {
+    const [x, y] = p.split(",").map(Number);
+    return `(list ${x} ${y})`;
+  });
+  const ptsStr = `(list ${ptList.join(" ")})`;
+  const codeMap = {
+    centroid: `(point:centroid ${ptsStr})`,
+    "convexhull": `(geometry:convexhull-by-graham-scan ${ptsStr})`,
+    "dist-point-line": `(progn
+  (setq ss (ssget ":S" (list (cons 0 "LINE"))))
+  (if ss
+    (progn
+      (setq e (car (pickset:to-list ss)))
+      (setq p1 (cdr (assoc 10 (entget e))))
+      (setq p2 (cdr (assoc 11 (entget e))))
+      (geometry:dist-pt-line (getpoint "\\n\u9009\u62E9\u6D4B\u91CF\u70B9: ") (list p1 p2))
+    )
+  )
+)`,
+    "in-curve-p": `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "LWPOLYLINE"))))))
+  (if e (point:in-curve-p (getpoint "\\n\u9009\u62E9\u6D4B\u8BD5\u70B9: ") e))
+)`,
+    transform: `(matrix:transformation (list 0 0 0) (list 2 2 1) 0 (list 0 0 0))`
+  };
+  const code = codeMap[action] || codeMap.centroid;
+  const descMap = {
+    centroid: `\u8BA1\u7B97 ${points} \u7684\u51E0\u4F55\u4E2D\u5FC3\uFF08\u8D28\u5FC3\uFF09`,
+    convexhull: `\u8BA1\u7B97 ${points} \u7684\u51F8\u5305\uFF08Graham Scan \u7B97\u6CD5\uFF09`,
+    "dist-point-line": "\u9009\u62E9\u4E00\u6761\u76F4\u7EBF\uFF0C\u7136\u540E\u62FE\u53D6\u4E00\u4E2A\u70B9\uFF0C\u8BA1\u7B97\u70B9\u5230\u76F4\u7EBF\u7684\u8DDD\u79BB",
+    "in-curve-p": "\u9009\u62E9\u4E00\u4E2A\u95ED\u5408 LWPOLYLINE\uFF0C\u7136\u540E\u62FE\u53D6\u4E00\u4E2A\u70B9\uFF0C\u68C0\u6D4B\u70B9\u662F\u5426\u5728\u66F2\u7EBF\u5185\u90E8",
+    transform: "\u5750\u6807\u53D8\u6362\u793A\u4F8B\uFF1A\u7F29\u653E2\u500D (matrix:transformation \u5E73\u79FB \u7F29\u653E \u65CB\u8F6C \u57FA\u70B9)"
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u51E0\u4F55\u8BA1\u7B97\uFF1A${descMap[action] || descMap.centroid}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateTextProcessPrompt(args) {
+  const { action = "remove-fmt", markdown = "\u8FD9\u662F **\u7C97\u4F53** \u548C *\u659C\u4F53* \u6587\u672C" } = args;
+  const codeMap = {
+    "remove-fmt": `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "MTEXT"))))))
+  (if e (text:remove-fmt (cdr (assoc 1 (entget e)))))
+)`,
+    "parse-mtext": `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "MTEXT"))))))
+  (if e (text:parse-mtext (cdr (assoc 1 (entget e)))))
+)`,
+    "from-markdown": `(text:from-markdown "${markdown}")`,
+    "mtext2text": `(progn
+  (setq e (car (pickset:to-list (ssget ":S" (list (cons 0 "MTEXT"))))))
+  (if e (text:mtext2text e))
+)`
+  };
+  const code = codeMap[action] || codeMap["remove-fmt"];
+  const descMap = {
+    "remove-fmt": "\u9009\u62E9\u4E00\u4E2AMTEXT\u5BF9\u8C61\uFF0C\u53BB\u9664\u6240\u6709\u683C\u5F0F\u4EE3\u7801\uFF0C\u8FD4\u56DE\u7EAF\u6587\u672C",
+    "parse-mtext": "\u9009\u62E9\u4E00\u4E2AMTEXT\u5BF9\u8C61\uFF0C\u89E3\u6790\u4E3A (\u683C\u5F0F\u6216\u6587\u672C . \u5185\u5BB9) \u5217\u8868",
+    "from-markdown": `\u5C06Markdown\u8F6C\u6362\u4E3AMTEXT\u683C\u5F0F\u4EE3\u7801\uFF1A
+${markdown}`,
+    "mtext2text": "\u9009\u62E9\u4E00\u4E2AMTEXT\u5BF9\u8C61\uFF0C\u5206\u89E3\u4E3A\u591A\u4E2A\u5355\u884CTEXT"
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u6587\u672C\u5904\u7406\uFF1A${descMap[action] || descMap["remove-fmt"]}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generatePicksetFilterPrompt(args) {
+  const { action = "by-type", dxfType = "LINE", layerName = "0" } = args;
+  const codeMap = {
+    "by-type": `(progn
+  (setq ss (ssget "_X" (list (cons 0 "${dxfType}"))))
+  (if ss (list (sslength ss) (mapcar (function (lambda (x) (cdr (assoc 0 (entget x))))) (pickset:to-list ss))))
+)`,
+    "by-layer": `(progn
+  (setq ss (ssget "_X" (list (cons 8 "${layerName}"))))
+  (if ss (list (sslength ss) (mapcar (function (lambda (x) (cdr (assoc 0 (entget x))))) (pickset:to-list ss))))
+)`,
+    "by-box": `(progn
+  (setq ss (ssget "_X"))
+  (if ss (pickset:getbox ss 0))
+)`,
+    erase: `(progn
+  (setq ss (ssget (list (cons 0 "${dxfType}"))))
+  (if ss (progn (pickset:erase ss) (princ (strcat "\u5DF2\u5220\u9664 " (itoa (sslength ss)) " \u4E2A " "${dxfType}" " \u5B9E\u4F53"))))
+)`,
+    zoom: `(progn
+  (setq ss (ssget "_X" (list (cons 0 "${dxfType}"))))
+  (if ss (pickset:zoom ss))
+)`
+  };
+  const code = codeMap[action] || codeMap["by-type"];
+  const descMap = {
+    "by-type": `\u7EDF\u8BA1\u6240\u6709\u7C7B\u578B\u4E3A ${dxfType} \u7684\u5B9E\u4F53\u6570\u91CF`,
+    "by-layer": `\u7EDF\u8BA1\u56FE\u5C42 ${layerName} \u4E0A\u7684\u5B9E\u4F53\u6570\u91CF\u548C\u7C7B\u578B`,
+    "by-box": "\u8BA1\u7B97\u5168\u56FE\u9009\u62E9\u96C6\u7684\u8FB9\u754C\u6846",
+    erase: `\u5220\u9664\u6240\u6709 ${dxfType} \u7C7B\u578B\u7684\u5B9E\u4F53`,
+    zoom: `\u7F29\u653E\u5230\u6240\u6709 ${dxfType} \u7C7B\u578B\u7684\u5B9E\u4F53`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u9009\u62E9\u96C6\u64CD\u4F5C\uFF1A${descMap[action] || descMap["by-type"]}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateColorConvertPrompt(args) {
+  const { action = "aci2rgb", value = "1" } = args;
+  const codeMap = {
+    aci2rgb: `(color:aci2rgb ${parseInt(value) || 1})`,
+    rgb2css: `(color:rgb2css (list ${value.split(",").map((v) => parseInt(v) || 0).join(" ")}))`,
+    truecolor2rgb: `(color:truecolor2rgb ${parseInt(value) || 16711680})`,
+    rgb2truecolor: `(color:rgb2truecolor (list ${value.split(",").map((v) => parseInt(v) || 0).join(" ")}))`,
+    rgb: `(color:rgb ${value.split(",").map((v) => parseInt(v) || 0).join(" ")})`
+  };
+  const code = codeMap[action] || codeMap.aci2rgb;
+  const descMap = {
+    aci2rgb: `ACI\u989C\u8272\u7D22\u5F15 ${value} \u8F6CRGB`,
+    rgb2css: `RGB (${value || "255,0,0"}) \u8F6CCSS\u989C\u8272 #FFFFFF`,
+    truecolor2rgb: `TrueColor\u6574\u6570 ${value} \u8F6CRGB\u5217\u8868`,
+    rgb2truecolor: `RGB (${value || "255,0,0"}) \u8F6CTrueColor\u6574\u6570`,
+    rgb: `\u8BA1\u7B97RGB\u5408\u6210\u503C\uFF1AR ${value.split(",")[0] || 255} G ${value.split(",")[1] || 0} B ${value.split(",")[2] || 0}`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `${descMap[action] || descMap.aci2rgb}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateJsonExchangePrompt(args) {
+  const { action = "encode", data = '(("name" . "\u5BA2\u5385") ("area" . 45.5) ("layer" . "A-WALL"))' } = args;
+  const codeMap = {
+    encode: `(json:encode-from-alist '${data})`,
+    decode: `(json:parse "${data.replace(/"/g, '\\"')}")`,
+    "decode-json": `(json:decode-json-from-string "${data.replace(/"/g, '\\"')}")`
+  };
+  const code = codeMap[action] || codeMap.encode;
+  const descMap = {
+    encode: `\u5C06alist\u6570\u636E\u7F16\u7801\u4E3AJSON\u5B57\u7B26\u4E32`,
+    decode: `\u4F7F\u7528\u7EAFLisp\u89E3\u6790\u5668\u89E3\u6790JSON\u5B57\u7B26\u4E32`,
+    "decode-json": `\u4F7F\u7528\u670D\u52A1\u5668API\u89E3\u7801JSON\u5B57\u7B26\u4E32\uFF08\u652F\u6301GBK\u7F16\u7801\uFF09`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `JSON\u6570\u636E\u4EA4\u6362\uFF1A${descMap[action] || descMap.encode}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u6570\u636E:
+${data}
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
+async function generateExcelReportPrompt(args) {
+  const { visible = "false", savePath = "" } = args;
+  const code = `(progn
+  ;; 1. \u7EDF\u8BA1\u56FE\u7EB8\u5B9E\u4F53
+  (setq ss (ssget "_X"))
+  (setq elst (if ss (pickset:to-list ss) nil))
+  (setq type-count (if elst (stat:stat (mapcar (function (lambda (x) (cdr (assoc 0 (entget x))))) elst)) nil))
+  
+  ;; 2. \u521B\u5EFAExcel
+  (setq xl (excel:new ${visible === "true" ? "nil" : "t"}))
+  
+  ;; 3. \u5199\u8868\u5934
+  (excel:set-rangevalue xl 1 "\u5B9E\u4F53\u7C7B\u578B")
+  (excel:set-rangevalue xl "B1" "\u6570\u91CF")
+  
+  ;; 4. \u5199\u5165\u6570\u636E
+  (setq row 2)
+  (foreach item type-count
+    (excel:set-rangevalue xl (list row 1) (car item))
+    (excel:set-rangevalue xl (list row 2) (cdr item))
+    (setq row (1+ row))
+  )
+  
+  ;; 5. \u83B7\u53D6\u56FE\u5C42\u5217\u8868
+  (setq layers (layer:list))
+  (excel:set-rangevalue xl (list 1 4) "\u56FE\u5C42\u5217\u8868")
+  (setq row 2)
+  (foreach lay layers
+    (excel:set-rangevalue xl (list row 4) lay)
+    (setq row (1+ row))
+  )
+  
+  ${savePath ? `(excel:saveas xl "${savePath}")` : ""}
+  (princ (strcat "Excel\u62A5\u8868\u5DF2\u751F\u6210\uFF0C\u5171 " (itoa (1- row)) " \u884C\u6570\u636E"))
+)`;
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `\u5BFC\u51FACAD\u5B9E\u4F53\u7EDF\u8BA1\u5230Excel\u62A5\u8868\uFF1A
+
+\`\`\`lisp
+${code}
+\`\`\`
+${savePath ? `
+\u4FDD\u5B58\u8DEF\u5F84: ${savePath}` : "\n\u6CE8\u610F\uFF1A\u8BF7\u66FF\u6362Excel\u4E3A\u53EF\u89C1\u6A21\u5F0F\u540E\u624B\u52A8\u4FDD\u5B58"}
+
+\u4F7F\u7528 \`eval_lisp\` \u6267\u884C\u3002`
+      }
+    }]
+  };
+}
+async function generateStringProcessPrompt(args) {
+  const { action = "format", input = "Hello, {0}!", arg1 = "World", arg2 = "" } = args;
+  const codeMap = {
+    format: `(string:format "${input}" (list "${arg1}"))`,
+    split: `(string:split "${input}" "${arg1}")`,
+    "subst-all": `(string:subst-all "${arg2}" "${arg1}" "${input}")`,
+    regexp: `(re:match "${arg1}" "${input}")`,
+    trim: `(string:trim-space "${input}")`,
+    number2chinese: `(string:number2chinese ${parseInt(input) || 12345})`,
+    "to-list": `(string:to-list "${input}" "${arg1}")`
+  };
+  const code = codeMap[action] || codeMap.format;
+  const descMap = {
+    format: `\u683C\u5F0F\u5316: ${input} \u53C2\u6570: ${arg1}`,
+    split: `\u62C6\u5206: "${input}" \u6309 "${arg1}" \u5206\u9694`,
+    "subst-all": `\u66FF\u6362: \u5C06 "${input}" \u4E2D\u7684 "${arg1}" \u66FF\u6362\u4E3A "${arg2}"`,
+    regexp: `\u6B63\u5219\u5339\u914D: "${input}" \u6A21\u5F0F: ${arg1}`,
+    trim: `\u53BB\u9664\u9996\u5C3E\u7A7A\u683C: "${input}"`,
+    number2chinese: `\u6570\u5B57 ${parseInt(input) || 12345} \u8F6C\u4E2D\u6587\u5927\u5199`,
+    "to-list": `\u6309\u5206\u9694\u7B26 "${arg1}" \u62C6\u5206 "${input}" \u4E3A\u5217\u8868`
+  };
+  return {
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `${descMap[action] || descMap.format}
+
+\`\`\`lisp
+${code}
+\`\`\`
+
+\u4F7F\u7528 \`eval_lisp_with_result\` \u6267\u884C\u83B7\u53D6\u7ED3\u679C\u3002`
+      }
+    }]
+  };
+}
 
 // src/session-manager.js
 var Session = class {
@@ -1579,11 +2045,9 @@ var SseSession = class {
     return lines.join("\n") + "\n\n";
   }
   _setupDrain() {
-    if (typeof this.#res.on !== "function")
-      return;
+    if (typeof this.#res.on !== "function") return;
     this.#drainHandler = () => {
-      if (!this.#active)
-        return;
+      if (!this.#active) return;
       if (this.#backpressureBuffer.length > 0) {
         this._drainBuffer();
       }
@@ -1605,8 +2069,7 @@ var SseSession = class {
     }
   }
   _write(content) {
-    if (!this.#active)
-      return false;
+    if (!this.#active) return false;
     try {
       if (this.#backpressureBuffer.length > 0) {
         this.#backpressureBuffer.push(content);
@@ -1876,8 +2339,7 @@ var SERVER_CAPABILITIES = {
   prompts: {}
 };
 var { port, host, transport, apiKey, rateLimitWindow, rateLimitMax } = config_default;
-if (apiKey)
-  log("API Key authentication enabled");
+if (apiKey) log("API Key authentication enabled");
 var mcpLimiter = rateLimit({
   windowMs: rateLimitWindow,
   max: rateLimitMax,
@@ -1927,8 +2389,7 @@ ${CAD_PLATFORMS.join("\n")}
   list_symbols: (a) => listSymbols(a.package),
   import_funlib: async (a) => {
     const data = await loadAtlibFunctionLib();
-    if (!data)
-      return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
+    if (!data) return { content: [{ type: "text", text: "\u52A0\u8F7D\u51FD\u6570\u5E93\u5931\u8D25" }], isError: true };
     if (a.format === "list") {
       const items = Object.values(data.all_functions || {}).map((f) => `${f.name}: ${f.description || ""}`);
       return { content: [{ type: "text", text: items.join("\n") }] };
@@ -2090,8 +2551,7 @@ var tools = [
 ];
 async function handleToolCall(name, args) {
   const handler = TOOL_HANDLERS[name];
-  if (!handler)
-    return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
+  if (!handler) return { content: [{ type: "text", text: `\u672A\u77E5\u5DE5\u5177: ${name}` }], isError: true };
   try {
     const result = await handler(args || {});
     notifyResourceChanges(name);
@@ -2212,8 +2672,7 @@ async function startServer() {
     const JSON_CONTENT_TYPES = ["application/json", "application/json-rpc", "application/vnd.api+json"];
     app.use(async (req, res, next) => {
       const ct = (req.headers["content-type"] || "").toLowerCase();
-      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t)))
-        return next();
+      if (!JSON_CONTENT_TYPES.some((t) => ct.startsWith(t))) return next();
       try {
         const buf = await rawBody(req, { limit: "10mb" });
         const m = ct.match(/charset\s*=\s*([^\s;]+)/i);
@@ -2234,11 +2693,9 @@ async function startServer() {
     const PUBLIC_PATHS = ["/health"];
     if (apiKey) {
       app.use((req, res, next) => {
-        if (PUBLIC_PATHS.includes(req.path))
-          return next();
+        if (PUBLIC_PATHS.includes(req.path)) return next();
         const auth = req.get("Authorization");
-        if (auth === `Bearer ${apiKey}`)
-          return next();
+        if (auth === `Bearer ${apiKey}`) return next();
         res.status(401).json({ error: "Unauthorized" });
       });
     }
@@ -2253,8 +2710,7 @@ async function startServer() {
         res.setHeader("Access-Control-Expose-Headers", "mcp-session-id, content-type, x-accel-buffering");
         res.setHeader("Access-Control-Max-Age", "86400");
         res.setHeader("Vary", "Accept");
-        if (req.method === "OPTIONS")
-          return res.status(204).end();
+        if (req.method === "OPTIONS") return res.status(204).end();
         next();
       });
     }

package/dist/cad-worker.js

@@ -129,7 +129,7 @@ const cadSendWithResult = edge.func(function() {/*
           string platform = d.platform.ToString();
           string encoding = d.encoding != null ? d.encoding.ToString() : "";
           string progId = platform + ".Application";
-          string tempDir = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "@lisp");
+          string tempDir = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "@lisp", "tmp");
           System.IO.Directory.CreateDirectory(tempDir);
           
           tempFile = System.IO.Path.Combine(tempDir, "atlisp_result_" + System.Guid.NewGuid().ToString("N") + ".txt");
@@ -440,6 +440,17 @@ async function handleMessage(msg) {
     if (!parenCheck.valid) {
       return { success: false, error: `括号错误: ${parenCheck.error} (位置 ${parenCheck.pos})` };
     }
+    if (msg.code.length > 255) {
+      log(`send (long code ${msg.code.length} chars, fallback to sendResult): ${msg.code.substring(0, 80)}...`);
+      const r = await new Promise((resolve, reject) => {
+        cadSendWithResult({ code: msg.code, platform: msg.platform || 'AutoCAD', encoding: '' }, (e, r) => {
+          if (e) reject(e);
+          else resolve(r);
+        });
+      });
+      log(`send result (long code): ${JSON.stringify(r)}`);
+      return r;
+    }
     const maxRetries = 3;
     let lastError = null;
     for (let i = 0; i < maxRetries; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atlisp/mcp",
-    "version": "1.3.4",
+    "version": "1.3.7",
     "description": "MCP Server for @lisp on CAD",
     "type": "module",
     "bin": {