@atlisp/mcp 1.3.7 → 1.4.0

package/dist/atlisp-mcp.js

@@ -34,7 +34,8 @@ 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);
@@ -43,7 +44,8 @@ var SessionTransport = class {
     }
   }
   async close() {
-    if (this._closed) return;
+    if (this._closed)
+      return;
     this._closed = true;
     if (this._pendingRequest) {
       const { reject, timeout } = this._pendingRequest;
@@ -117,7 +119,7 @@ var FILE_EXTENSIONS = {
   "BricsCAD": [".des"]
 };
 var SERVER_NAME = "atlisp-mcp-server";
-var SERVER_VERSION = "1.1.2";
+var SERVER_VERSION = "1.4.0";
 var MOCK_PACKAGES = [
   { name: "base", description: "\u57FA\u7840\u51FD\u6570\u5E93", version: "1.0.0" },
   { name: "at-pm", description: "\u5DE5\u7A0B\u9879\u76EE\u7BA1\u7406", version: "2.1.0" },
@@ -210,7 +212,8 @@ 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;
@@ -235,7 +238,8 @@ 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"]
     });
@@ -244,7 +248,8 @@ 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);
@@ -263,7 +268,8 @@ function getWorker() {
   return worker;
 }
 function startHeartbeat() {
-  if (heartbeatTimer) clearInterval(heartbeatTimer);
+  if (heartbeatTimer)
+    clearInterval(heartbeatTimer);
   heartbeatTimer = setInterval(async () => {
     try {
       const result = await sendMessage({ type: "ping" });
@@ -308,7 +314,8 @@ 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) {
@@ -324,13 +331,16 @@ 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 || "";
@@ -344,7 +354,8 @@ 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;
@@ -353,7 +364,8 @@ 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 };
@@ -362,7 +374,8 @@ 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;
@@ -371,7 +384,8 @@ 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;
@@ -380,7 +394,8 @@ 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() {
@@ -455,7 +470,8 @@ async function evalLisp(code, withResult = false, encoding = null) {
     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" }] };
+  if (!trimmed)
+    return { content: [{ type: "text", text: "\u547D\u4EE4\u4E3A\u7A7A\uFF0C\u672A\u53D1\u9001" }] };
   try {
     if (withResult) {
       const result = await cad.sendCommandWithResult(trimmed, encoding);
@@ -475,14 +491,17 @@ 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 };
+  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" }] };
+  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" }] };
 }
@@ -490,7 +509,8 @@ 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" }] };
@@ -501,7 +521,8 @@ 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" }] };
@@ -512,7 +533,8 @@ 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" }] };
@@ -521,20 +543,68 @@ 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 };
   }
 }
+async function getSystemStatus() {
+  const status = {
+    mcp: { version: process.env.npm_package_version || "unknown" },
+    worker: { alive: false },
+    cad: { connected: false, platform: null, version: null, busy: false, hasDoc: false },
+    lisp: { available: false, testResult: null, error: null },
+    packages: null
+  };
+  try {
+    status.worker.alive = await cad.ping();
+  } catch {
+    status.worker.alive = false;
+  }
+  status.cad.connected = cad.connected;
+  if (cad.connected) {
+    status.cad.platform = cad.getPlatform();
+    status.cad.version = cad.getVersion();
+    try {
+      status.cad.busy = await cad.isBusy();
+    } catch {
+    }
+    try {
+      const doc = await cad.hasDoc();
+      status.cad.hasDoc = doc.hasDoc;
+    } catch {
+    }
+    try {
+      const r = await cad.sendCommandWithResult("(+ 1 2)");
+      if (r !== null && r !== void 0) {
+        status.lisp.available = true;
+        status.lisp.testResult = String(r).trim();
+      }
+    } catch (e) {
+      status.lisp.error = e.message;
+    }
+    try {
+      const pkgResult = await cad.sendCommandWithResult("(@::package-list-in-local)");
+      if (pkgResult && pkgResult !== "nil") {
+        status.packages = pkgResult;
+      }
+    } catch {
+    }
+  }
+  return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+}
 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)
@@ -574,10 +644,13 @@ 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")}` }] };
@@ -594,10 +667,12 @@ 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` }] };
@@ -639,7 +714,8 @@ 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}`);
@@ -650,7 +726,8 @@ 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) {
@@ -730,12 +807,26 @@ function getCached(key) {
 function setCache(key, data) {
   resourceCache.set(key, { data, timestamp: Date.now() });
 }
+function clearCache(uri) {
+  if (uri) {
+    for (const key of resourceCache.keys()) {
+      if (key.startsWith(uri.split("://")[1]?.split("/")[0] + ":")) {
+        resourceCache.delete(key);
+      }
+    }
+  } else {
+    resourceCache.clear();
+  }
+}
 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 = "";
@@ -777,15 +868,21 @@ 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;
   });
 }
@@ -800,14 +897,16 @@ 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 };
 }
@@ -843,7 +942,8 @@ 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();
   }
@@ -870,9 +970,12 @@ 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);
@@ -919,8 +1022,10 @@ 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);
@@ -974,8 +1079,10 @@ 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);
@@ -985,8 +1092,10 @@ 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")))
@@ -1004,7 +1113,8 @@ 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]) };
@@ -1015,17 +1125,71 @@ async function getDwgPath() {
   }
 }
 async function getPackages(filterName = null) {
-  const packages = MOCK_PACKAGES.map((p) => ({
-    name: p.name,
-    version: p.version,
-    description: p.description,
-    loaded: true
-  }));
-  if (filterName) {
-    const pkg = packages.find((p) => p.name === filterName);
-    return pkg ? [pkg] : [];
+  const cacheKey = filterName ? `packages:${filterName}` : "packages:all";
+  const cached = getCached(cacheKey);
+  if (cached)
+    return cached;
+  if (!cad.connected)
+    await cad.connect();
+  if (!cad.connected)
+    return [];
+  try {
+    const code = `(mapcar 'cdr @::*local-pkgs*)`;
+    const result = await cad.sendCommandWithResult(code);
+    if (!result || result === "" || result === "nil") {
+      setCache(cacheKey, []);
+      return [];
+    }
+    let raw = [];
+    try {
+      raw = JSON.parse(result);
+    } catch {
+      raw = parseLispList(result) || [];
+    }
+    if (!Array.isArray(raw))
+      raw = [];
+    const packages = raw.map((item) => {
+      if (Array.isArray(item)) {
+        const pkg = { name: "", version: "0.0.0", description: "", loaded: true };
+        for (const entry of item) {
+          if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+            const [[key, val]] = Object.entries(entry);
+            const k = String(key);
+            const v = String(val);
+            if (k === ":NAME")
+              pkg.name = v;
+            else if (k === ":VERSION")
+              pkg.version = v;
+            else if (k === ":DESCRIPTION")
+              pkg.description = v;
+            else if (k === ":FULL-NAME")
+              pkg.fullName = v;
+            else if (k === ":AUTHOR")
+              pkg.author = v;
+            else if (k === ":CATEGORY")
+              pkg.category = v;
+            else if (k === ":URL")
+              pkg.url = v;
+          }
+        }
+        return pkg;
+      }
+      if (typeof item === "string" || typeof item === "number") {
+        return { name: String(item), version: "0.0.0", loaded: true };
+      }
+      return null;
+    }).filter(Boolean);
+    if (filterName) {
+      const filtered = packages.filter((p) => p.name === filterName);
+      setCache(cacheKey, filtered);
+      return filtered;
+    }
+    setCache(cacheKey, packages);
+    return packages;
+  } catch (e) {
+    setCache(cacheKey, []);
+    return [];
   }
-  return packages;
 }
 function getPlatforms() {
   return CAD_PLATFORMS.map((name) => ({
@@ -1314,10 +1478,14 @@ ${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) {
@@ -2045,9 +2213,11 @@ 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();
       }
@@ -2069,7 +2239,8 @@ 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);
@@ -2339,7 +2510,8 @@ 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,
@@ -2387,9 +2559,11 @@ ${CAD_PLATFORMS.join("\n")}
   init_atlisp: () => initAtlisp(),
   get_function_usage: (a) => getFunctionUsage(a.name, a.package),
   list_symbols: (a) => listSymbols(a.package),
+  get_system_status: () => getSystemStatus(),
   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") }] };
@@ -2547,11 +2721,17 @@ var tools = [
         format: { type: "string", enum: ["json", "list"], description: "\u8FD4\u56DE\u683C\u5F0F\uFF1Ajson\uFF08\u5B8C\u6574JSON\uFF09\u6216 list\uFF08\u51FD\u6570\u540D:\u63CF\u8FF0 \u5217\u8868\uFF09\uFF0C\u9ED8\u8BA4 json" }
       }
     }
+  },
+  {
+    name: "get_system_status",
+    description: "\u83B7\u53D6\u5B8C\u6574\u7CFB\u7EDF\u8BCA\u65AD\u4FE1\u606F\uFF1AMCP \u72B6\u6001\u3001CAD \u8FDE\u63A5\u3001Lisp \u6267\u884C\u3001\u5305\u5217\u8868",
+    inputSchema: { type: "object", properties: {} }
   }
 ];
 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);
@@ -2563,14 +2743,16 @@ async function handleToolCall(name, args) {
 }
 function notifyResourceChanges(toolName) {
   const resourceMap = {
-    connect_cad: ["atlisp://cad/info"],
+    connect_cad: ["atlisp://cad/info", "atlisp://cad/layers", "atlisp://dwg/name", "atlisp://dwg/path", "atlisp://packages"],
     new_document: ["atlisp://dwg/name", "atlisp://dwg/path", "atlisp://cad/layers", "atlisp://cad/entities"],
     install_package: ["atlisp://packages"],
-    install_atlisp: ["atlisp://packages"]
+    install_atlisp: ["atlisp://packages", "atlisp://cad/info"],
+    init_atlisp: ["atlisp://packages", "atlisp://cad/info"]
   };
   const uris = resourceMap[toolName];
   if (uris) {
     for (const uri of uris) {
+      clearCache(uri);
       if (isSubscribed(uri)) {
         notify(uri, null);
       }
@@ -2672,7 +2854,8 @@ 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);
@@ -2693,9 +2876,11 @@ 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" });
       });
     }
@@ -2710,7 +2895,8 @@ 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/package.json

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