@atlisp/mcp 1.8.23 → 1.8.25

package/dist/config.js

@@ -4,41 +4,42 @@ import path from 'path';
 import os from 'os';
 
 const envSchema = z.object({
-    PORT: z.string().optional().default('8110'),
+    PORT: z.coerce.number().optional().default(8110),
     HOST: z.string().optional().default('0.0.0.0'),
     TRANSPORT: z.enum(['http', 'stdio', 'ws']).optional().default('http'),
     MCP_API_KEY: z.string().optional().default(''),
-    ENABLE_SSE: z.string().optional().default('true'),
-    MESSAGE_TIMEOUT: z.string().optional().default('60000'),
-    HEARTBEAT_INTERVAL: z.string().optional().default('30000'),
-    BUSY_RETRIES: z.string().optional().default('10'),
-    BUSY_DELAY: z.string().optional().default('500'),
-    ENABLE_CORS: z.string().optional().default('true'),
-    CORS_ORIGIN: z.string().optional().default('*'),
-    RATE_LIMIT_WINDOW: z.string().optional().default('60000'),
-    RATE_LIMIT_MAX: z.string().optional().default('100'),
-    RESOURCE_CACHE_TTL: z.string().optional().default('5000'),
-    FUNCTION_LIB_CACHE_TTL: z.string().optional().default('300000'),
-    DEBUG: z.string().optional().default('false'),
+    ENABLE_SSE: z.coerce.boolean().optional().default(true),
+    MESSAGE_TIMEOUT: z.coerce.number().optional().default(60000),
+    HEARTBEAT_INTERVAL: z.coerce.number().optional().default(30000),
+    BUSY_RETRIES: z.coerce.number().optional().default(10),
+    BUSY_DELAY: z.coerce.number().optional().default(500),
+    ENABLE_CORS: z.coerce.boolean().optional().default(true),
+    CORS_ORIGIN: z.string().optional().default('https://atlisp.cn'),
+    RATE_LIMIT_WINDOW: z.coerce.number().optional().default(60000),
+    RATE_LIMIT_MAX: z.coerce.number().optional().default(100),
+    RESOURCE_CACHE_TTL: z.coerce.number().optional().default(5000),
+    FUNCTION_LIB_CACHE_TTL: z.coerce.number().optional().default(300000),
+    DEBUG: z.coerce.boolean().optional().default(false),
     DEBUG_FILE: z.string().optional().default(''),
     FUNCTION_LIB_URL: z.string().optional().default('http://s3.atlisp.cn/json/functions.json'),
     CONFIG_FILE: z.string().optional().default(''),
-    API_KEY_RATE_LIMIT: z.string().optional().default('1000'),
-    METRICS_ENABLED: z.string().optional().default('true'),
-    REQUEST_LOG_ENABLED: z.string().optional().default('true'),
+    API_KEY_RATE_LIMIT: z.coerce.number().optional().default(1000),
+    METRICS_ENABLED: z.coerce.boolean().optional().default(true),
+    REQUEST_LOG_ENABLED: z.coerce.boolean().optional().default(true),
     SSL_KEY_PATH: z.string().optional().default(''),
     SSL_CERT_PATH: z.string().optional().default(''),
     LLM_API_KEY: z.string().optional().default(''),
     LLM_API_URL: z.string().optional().default('https://api.openai.com/v1/chat/completions'),
     LLM_MODEL: z.string().optional().default('gpt-4o-mini'),
-    LLM_MAX_TOKENS: z.string().optional().default('4096'),
-    LLM_TEMPERATURE: z.string().optional().default('0.7'),
-    WORKER_POOL_SIZE: z.string().optional().default('2'),
+    LLM_MAX_TOKENS: z.coerce.number().optional().default(4096),
+    LLM_TEMPERATURE: z.coerce.number().optional().default(0.7),
+    WORKER_POOL_SIZE: z.coerce.number().optional().default(2),
     LINT_PRESET: z.string().optional().default(''),
     LINT_CONFIG_PATH: z.string().optional().default(''),
     LINT_LEVEL: z.string().optional().default(''),
-    NO_LINT: z.string().optional().default(''),
+    NO_LINT: z.coerce.boolean().optional().default(false),
     SECURITY_LEVEL: z.string().optional().default('strict'),
+    CLIENT_ID: z.string().optional().default(''),
 });
 
 const configSchema = z.object({
@@ -83,6 +84,7 @@ const configSchema = z.object({
     lintLevel: z.string().optional(),
     noLint: z.boolean().optional(),
     securityLevel: z.enum(['strict', 'standard', 'relaxed']).optional(),
+    clientId: z.string().optional(),
 });
 
 function parseArgs() {
@@ -97,7 +99,7 @@ function parseArgs() {
         } else if (args[i] === '--ws') {
             result.transport = 'ws';
         } else if (args[i] === '--port' && args[i + 1]) {
-            result.port = args[i + 1];
+            result.port = parseInt(args[i + 1], 10);
             i++;
         } else if (args[i] === '--host' && args[i + 1]) {
             result.host = args[i + 1];
@@ -166,43 +168,44 @@ const configFilePath = env.CONFIG_FILE || cliArgs.configFile ||
 const fileConfig = loadConfigFile(configFilePath);
 
 const config = {
-    port: fileConfig?.port || parseInt(cliArgs.port || env.PORT, 10),
-    host: fileConfig?.host || cliArgs.host || env.HOST,
+    port: fileConfig?.port ?? cliArgs.port ?? env.PORT,
+    host: fileConfig?.host ?? cliArgs.host ?? env.HOST,
     transport: fileConfig?.transport ?? cliArgs.transport ?? env.TRANSPORT,
-    apiKey: fileConfig?.apiKey || env.MCP_API_KEY,
-    enableSse: fileConfig?.enableSse ?? (env.ENABLE_SSE === 'true'),
-    messageTimeout: fileConfig?.messageTimeout || parseInt(env.MESSAGE_TIMEOUT, 10),
-    heartbeatInterval: fileConfig?.heartbeatInterval || parseInt(env.HEARTBEAT_INTERVAL, 10),
-    busyRetries: fileConfig?.busyRetries || parseInt(env.BUSY_RETRIES, 10),
-    busyDelay: fileConfig?.busyDelay || parseInt(env.BUSY_DELAY, 10),
-    enableCors: fileConfig?.enableCors ?? (env.ENABLE_CORS === 'true'),
-    corsOrigin: fileConfig?.corsOrigin || env.CORS_ORIGIN,
-    rateLimitWindow: fileConfig?.rateLimitWindow || parseInt(env.RATE_LIMIT_WINDOW, 10),
-    rateLimitMax: fileConfig?.rateLimitMax || parseInt(env.RATE_LIMIT_MAX, 10),
-    resourceCacheTtl: fileConfig?.resourceCacheTtl || parseInt(env.RESOURCE_CACHE_TTL, 10),
-    functionLibCacheTtl: fileConfig?.functionLibCacheTtl || parseInt(env.FUNCTION_LIB_CACHE_TTL, 10),
-    debug: fileConfig?.debug ?? (env.DEBUG === 'true'),
-    debugFile: fileConfig?.debugFile || env.DEBUG_FILE,
-    functionLibUrl: fileConfig?.functionLibUrl || env.FUNCTION_LIB_URL,
+    apiKey: fileConfig?.apiKey ?? env.MCP_API_KEY,
+    enableSse: fileConfig?.enableSse ?? env.ENABLE_SSE,
+    messageTimeout: fileConfig?.messageTimeout ?? env.MESSAGE_TIMEOUT,
+    heartbeatInterval: fileConfig?.heartbeatInterval ?? env.HEARTBEAT_INTERVAL,
+    busyRetries: fileConfig?.busyRetries ?? env.BUSY_RETRIES,
+    busyDelay: fileConfig?.busyDelay ?? env.BUSY_DELAY,
+    enableCors: fileConfig?.enableCors ?? env.ENABLE_CORS,
+    corsOrigin: fileConfig?.corsOrigin ?? env.CORS_ORIGIN,
+    rateLimitWindow: fileConfig?.rateLimitWindow ?? env.RATE_LIMIT_WINDOW,
+    rateLimitMax: fileConfig?.rateLimitMax ?? env.RATE_LIMIT_MAX,
+    resourceCacheTtl: fileConfig?.resourceCacheTtl ?? env.RESOURCE_CACHE_TTL,
+    functionLibCacheTtl: fileConfig?.functionLibCacheTtl ?? env.FUNCTION_LIB_CACHE_TTL,
+    debug: fileConfig?.debug ?? env.DEBUG,
+    debugFile: fileConfig?.debugFile ?? env.DEBUG_FILE,
+    functionLibUrl: fileConfig?.functionLibUrl ?? env.FUNCTION_LIB_URL,
     configFile: configFilePath,
-    apiKeyRateLimit: fileConfig?.apiKeyRateLimit || parseInt(env.API_KEY_RATE_LIMIT, 10),
-    apiKeys: fileConfig?.apiKeys || [],
-    metricsEnabled: fileConfig?.metricsEnabled ?? (env.METRICS_ENABLED === 'true'),
-    requestLogEnabled: fileConfig?.requestLogEnabled ?? (env.REQUEST_LOG_ENABLED !== 'false'),
-    sslKey: fileConfig?.sslKey || env.SSL_KEY_PATH || cliArgs.sslKey,
-    sslCert: fileConfig?.sslCert || env.SSL_CERT_PATH || cliArgs.sslCert,
-    llmApiKey: fileConfig?.llmApiKey || env.LLM_API_KEY,
-    llmApiUrl: fileConfig?.llmApiUrl || env.LLM_API_URL,
-    llmModel: fileConfig?.llmModel || env.LLM_MODEL,
-    llmMaxTokens: fileConfig?.llmMaxTokens || parseInt(env.LLM_MAX_TOKENS, 10),
-    llmTemperature: fileConfig?.llmTemperature || parseFloat(env.LLM_TEMPERATURE),
-    maxPoolSize: fileConfig?.maxPoolSize || 3,
-    workerPoolSize: fileConfig?.workerPoolSize || parseInt(env.WORKER_POOL_SIZE, 10),
-    lintPreset: fileConfig?.lintPreset || cliArgs.lintPreset || env.LINT_PRESET || undefined,
-    lintConfigPath: fileConfig?.lintConfigPath || cliArgs.lintConfigPath || env.LINT_CONFIG_PATH || undefined,
-    lintLevel: fileConfig?.lintLevel || cliArgs.lintLevel || env.LINT_LEVEL || undefined,
-    noLint: fileConfig?.noLint ?? cliArgs.noLint ?? (env.NO_LINT === 'true'),
+    apiKeyRateLimit: fileConfig?.apiKeyRateLimit ?? env.API_KEY_RATE_LIMIT,
+    apiKeys: fileConfig?.apiKeys ?? [],
+    metricsEnabled: fileConfig?.metricsEnabled ?? env.METRICS_ENABLED,
+    requestLogEnabled: fileConfig?.requestLogEnabled ?? env.REQUEST_LOG_ENABLED,
+    sslKey: fileConfig?.sslKey ?? env.SSL_KEY_PATH ?? cliArgs.sslKey,
+    sslCert: fileConfig?.sslCert ?? env.SSL_CERT_PATH ?? cliArgs.sslCert,
+    llmApiKey: fileConfig?.llmApiKey ?? env.LLM_API_KEY,
+    llmApiUrl: fileConfig?.llmApiUrl ?? env.LLM_API_URL,
+    llmModel: fileConfig?.llmModel ?? env.LLM_MODEL,
+    llmMaxTokens: fileConfig?.llmMaxTokens ?? env.LLM_MAX_TOKENS,
+    llmTemperature: fileConfig?.llmTemperature ?? env.LLM_TEMPERATURE,
+    maxPoolSize: fileConfig?.maxPoolSize ?? 3,
+    workerPoolSize: fileConfig?.workerPoolSize ?? env.WORKER_POOL_SIZE,
+    lintPreset: fileConfig?.lintPreset ?? cliArgs.lintPreset ?? (env.LINT_PRESET || undefined),
+    lintConfigPath: fileConfig?.lintConfigPath ?? cliArgs.lintConfigPath ?? (env.LINT_CONFIG_PATH || undefined),
+    lintLevel: fileConfig?.lintLevel ?? cliArgs.lintLevel ?? (env.LINT_LEVEL || undefined),
+    noLint: fileConfig?.noLint ?? cliArgs.noLint ?? env.NO_LINT,
     securityLevel: fileConfig?.securityLevel ?? cliArgs.securityLevel ?? (env.SECURITY_LEVEL || 'strict'),
+    clientId: fileConfig?.clientId ?? (env.CLIENT_ID || ''),
 };
 
 if (config.lintConfigPath) process.env.LINT_CONFIG_PATH = config.lintConfigPath;
@@ -283,4 +286,4 @@ export function onConfigChange(callback) {
     configWatchers.push(callback);
 }
 
-export default config;
+export default config;

package/dist/handlers/meta-handlers.js

@@ -0,0 +1,70 @@
+import { tools } from '../tools/index.js';
+import { listPrompts, getPrompt } from './prompt-handlers.js';
+
+export async function search_tools(a) {
+    const q = (a.query || '').toLowerCase();
+    const results = tools.filter(t => t.name.toLowerCase().includes(q) || (t.description || '').toLowerCase().includes(q));
+    const text = results.length ? `找到 ${results.length} 个工具:\n${results.map(t => `${t.name}: ${t.description}`).join('\n')}` : `未找到包含 "${a.query}" 的工具`;
+    return { content: [{ type: 'text', text }] };
+}
+
+export async function list_tools_by_category(a) {
+    const categories = {};
+    for (const t of tools) {
+        const cat = t.annotations?.category || '其他';
+        if (!categories[cat]) categories[cat] = [];
+        categories[cat].push(t.name);
+    }
+    if (a.category) {
+        const names = categories[a.category];
+        return { content: [{ type: 'text', text: names ? `${a.category} (${names.length}):\n${names.join('\n')}` : `未找到分类: ${a.category}` }] };
+    }
+    const lines = [];
+    for (const [cat, names] of Object.entries(categories)) {
+        lines.push(`## ${cat} (${names.length})`);
+    }
+    lines.push(`\n共 ${Object.keys(categories).length} 个分类`);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+export async function get_tool_info(a) {
+    if (!a.name) return { content: [{ type: 'text', text: '需要 name 参数（工具名称）' }], isError: true };
+    const tool = tools.find(t => t.name === a.name);
+    if (!tool) return { content: [{ type: 'text', text: `未找到工具: ${a.name}` }], isError: true };
+
+    const ann = tool.annotations || {};
+    const required = (tool.inputSchema?.required || []).join(', ') || '无';
+    const props = tool.inputSchema?.properties || {};
+    const params = Object.entries(props).map(([k, v]) => {
+        const req = required.includes(k) ? '必填' : '可选';
+        const desc = v.description || '';
+        return `  ${k} (${req}): ${desc}`;
+    }).join('\n');
+
+    const lines = [
+        `## ${tool.name}`,
+        `描述: ${tool.description || '无'}`,
+        `分类: ${ann.category || '其他'}`,
+        `只读: ${ann.readOnlyHint ? '是' : '否'}`,
+        `破坏性: ${ann.destructiveHint ? '是' : '否'}`,
+        `幂等: ${ann.idempotentHint ? '是' : '否'}`,
+        `开放世界: ${ann.openWorldHint ? '是' : '否'}`,
+        ``,
+        `参数:`,
+        params || '  无参数',
+    ];
+    if (ann.deprecatedReason) {
+        lines.push(`\n已弃用: ${ann.deprecatedReason}`);
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+export async function list_prompts_handler() {
+    const prompts = await listPrompts();
+    return { content: [{ type: 'text', text: JSON.stringify(prompts) }] };
+}
+
+export async function get_prompt_handler(a) {
+    const prompt = await getPrompt(a.name, a.args || {});
+    return { content: prompt.messages.map(m => ({ type: 'text', text: m.content.text || m.content })) };
+}

package/dist/handlers/resource-cache.js

@@ -1,18 +1,36 @@
 import config from '../config.js';
 
-const CACHE_TTL = config.resourceCacheTtl;
-const resourceCache = new Map();
 const CLEANUP_INTERVAL = 60000;
 
 let cleanupTimer = null;
+let _instanceKey = null;
+
+// instance -> Map(key -> {data, timestamp})
+const _instanceCaches = new Map();
+const _defaultKey = '__default__';
+
+function _getCache() {
+  const key = _instanceKey || _defaultKey;
+  if (!_instanceCaches.has(key)) {
+    _instanceCaches.set(key, new Map());
+  }
+  return _instanceCaches.get(key);
+}
+
+function _ttl() {
+  return config.resourceCacheTtl;
+}
 
 function ensureCleanup() {
   if (cleanupTimer) return;
   cleanupTimer = setInterval(() => {
     const now = Date.now();
-    for (const [key, entry] of resourceCache) {
-      if (now - entry.timestamp >= CACHE_TTL) {
-        resourceCache.delete(key);
+    const ttl = _ttl();
+    for (const cache of _instanceCaches.values()) {
+      for (const [key, entry] of cache) {
+        if (now - entry.timestamp >= ttl) {
+          cache.delete(key);
+        }
       }
     }
   }, CLEANUP_INTERVAL);
@@ -21,7 +39,17 @@ function ensureCleanup() {
 
 ensureCleanup();
 
-// 每个资源 URI 对应的 cache key 前缀映射
+export function stopCleanup() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}
+
+export function setInstanceKey(key) {
+  _instanceKey = key || null;
+}
+
 const URI_CACHE_PREFIX = {
   'atlisp://cad/info': 'cad:info',
   'atlisp://dwg/entities': 'dwg:entities',
@@ -35,28 +63,32 @@ const URI_CACHE_PREFIX = {
 };
 
 function getCached(key) {
-  const entry = resourceCache.get(key);
-  if (entry && Date.now() - entry.timestamp < CACHE_TTL) {
+  const cache = _getCache();
+  const entry = cache.get(key);
+  if (entry && Date.now() - entry.timestamp < _ttl()) {
     return entry.data;
   }
-  resourceCache.delete(key);
+  cache.delete(key);
   return null;
 }
 
 function setCache(key, data) {
-  resourceCache.set(key, { data, timestamp: Date.now() });
+  _getCache().set(key, { data, timestamp: Date.now() });
 }
 
 export function clearCache(uri) {
-  const prefix = URI_CACHE_PREFIX[uri];
-  if (prefix) {
-    for (const key of resourceCache.keys()) {
-      if (key === prefix || key.startsWith(prefix + ':')) {
-        resourceCache.delete(key);
+  const basePrefix = URI_CACHE_PREFIX[uri];
+  if (basePrefix) {
+    const cache = _getCache();
+    for (const key of cache.keys()) {
+      if (key === basePrefix || key.startsWith(basePrefix + ':')) {
+        cache.delete(key);
       }
     }
   } else if (!uri) {
-    resourceCache.clear();
+    const key = _instanceKey || _defaultKey;
+    _instanceCaches.delete(key);
+    _instanceCaches.set(key, new Map());
   }
 }
 

package/dist/handlers/resource-defs.js

@@ -22,6 +22,9 @@ export const RESOURCES = [
   { uri: 'atlisp://standards/coding', name: 'Coding Standards', description: '@lisp 编码规范', mimeType: 'application/json', subscribable: false },
   { uri: 'atlisp://dwg/context', name: 'DWG Context', description: '当前图纸上下文摘要。返回文档名/路径/布局/UCS/图层列表/实体统计/系统变量组合信息，帮助快速了解当前 CAD 状态', mimeType: 'application/json', subscribable: true },
   { uri: 'atlisp://tools/relationships', name: 'Tool Relationships', description: '工具依赖关系图。描述工具间的调用链关系（如 select_entities → batch_delete），帮助理解工具组合使用方式', mimeType: 'application/json', subscribable: false },
+  { uri: 'atlisp://dwg/analysis', name: 'Drawing Analysis', description: '当前图纸综合分析：实体类型统计、块使用统计、图层摘要、文字统计、系统变量快照。支持 ?type=summary（默认）或 ?type=detailed', mimeType: 'application/json', subscribable: true },
+  { uri: 'atlisp://tools/categories', name: 'Tool Categories', description: '工具分类概览。列出所有分类及其包含的工具数量', mimeType: 'application/json', subscribable: false },
+  { uri: 'atlisp://dwg/standards/check', name: 'Drawing Standards Check', description: '检查当前图纸是否符合加载的制图规范（图层命名、颜色、线型等规则）', mimeType: 'application/json', subscribable: false },
 ];
 
 export const TBL_INFO = {

package/dist/handlers/resource-handlers.js

@@ -6,6 +6,7 @@ import { log } from '../logger.js';
 import { parseLispList, parseLispRecursive, lispPairsToObject, escapeLispString } from '../handler-utils.js';
 import { createError, ERROR_CODES } from '../errors.js';
 import config from '../config.js';
+import { tools } from '../tools/index.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -1090,6 +1091,122 @@ async function getDwgContext() {
   }
 }
 
+async function getDrawingAnalysis(params = {}) {
+  const snapshot = await getCadSnapshot();
+  if (!snapshot || !snapshot.cadConnected) {
+    return { connected: false, error: 'CAD 未连接' };
+  }
+
+  try {
+    const detailedCode = `(progn
+  (vl-load-com)
+  (setq r nil)
+  ;; entity counts by type
+  (if (setq ss (ssget "_X"))
+    (progn
+      (setq total (sslength ss) i 0 cnt nil)
+      (while (< i total)
+        (setq typ (cdr (assoc 0 (entget (ssname ss i)))))
+        (setq cnt (if (assoc typ cnt) (subst (cons typ (1+ (cdr (assoc typ cnt)))) (assoc typ cnt) cnt) (cons (cons typ 1) cnt)))
+        (setq i (1+ i)))
+      (setq r (cons (cons "entityCount" total) r))
+      (setq r (cons (cons "entityByType" cnt) r)))
+    (setq r (cons (cons "entityCount" 0) r)))
+  ;; block usage
+  (setq blocks nil)
+  (vlax-for b (vla-get-blocks (vla-get-activedocument (vlax-get-acad-object)))
+    (if (and (= (vla-get-IsXref b) :vlax-false) (/= (vla-get-Name b) "*Model_Space") (/= (vla-get-Name b) "*Paper_Space"))
+      (setq blocks (cons (list "name" (vla-get-Name b) "count" (vla-get-Count b) "isDynamic" (vla-get-IsDynamicBlock b)) blocks))))
+  (setq r (cons (cons "blockUsage" blocks) r))
+  ;; layer summary
+  (setq layers nil le (tblnext "layer" t))
+  (while le
+    (setq ln (cdr (assoc 2 le)) lc (cdr (assoc 62 le)) ll (cdr (assoc 6 le)))
+    (setq layers (cons (list "name" ln "color" (if (< lc 0) (- lc) lc) "off" (< lc 0) "linetype" ll) layers))
+    (setq le (tblnext "layer" nil)))
+  (setq r (cons (cons "layers" layers) r))
+  ;; text stats
+  (if (setq ts (ssget "_X" '((0 . "TEXT,MTEXT"))))
+    (progn
+      (setq tc (sslength ts) th nil ti 0)
+      (while (< ti tc)
+        (setq h (cdr (assoc 40 (entget (ssname ts ti)))))
+        (if h (setq th (cons h th)))
+        (setq ti (1+ ti)))
+      (setq th (vl-sort th '<))
+      (setq r (cons (cons "textCount" tc) r))
+      (setq r (cons (cons "textHeights" (list "min" (car th) "max" (last th) "median" (nth (fix (/ (length th) 2)) th))) r)))
+    (setq r (cons (cons "textCount" 0) r)))
+  ;; system variables
+  (setq r (cons (cons "sysvars" (list
+    (cons "ltscale" (getvar "ltscale"))
+    (cons "dimscale" (getvar "dimscale"))
+    (cons "insunits" (getvar "insunits"))
+    (cons "measurement" (getvar "measurement"))
+    (cons "celtype" (getvar "celtype"))
+    (cons "clayer" (getvar "clayer"))
+    (cons "cecolor" (getvar "cecolor"))
+    (cons "osmode" (getvar "osmode"))
+    (cons "snapmode" (getvar "snapmode"))
+    (cons "gridmode" (getvar "gridmode"))
+    (cons "orthomode" (getvar "orthomode"))
+    (cons "plinetype" (getvar "plinetype"))
+    (cons "fillmode" (getvar "fillmode"))
+    (cons "pickstyle" (getvar "pickstyle"))
+  )) r))
+  (vl-prin1-to-string (reverse r)))`;
+
+    const resultStr = await cad.sendCommandWithResult(detailedCode);
+    const parsed = parseLispRecursive(resultStr);
+    if (!parsed || !Array.isArray(parsed)) {
+      return { connected: true, error: '分析结果解析失败' };
+    }
+    const analysis = {};
+    for (const pair of parsed) {
+      if (Array.isArray(pair) && pair.length >= 2) {
+        analysis[String(pair[0])] = pair[1];
+      }
+    }
+    return { connected: true, ...analysis };
+  } catch (e) {
+    log(`getDrawingAnalysis error: ${e.message}`);
+    return { connected: true, error: e.message };
+  }
+}
+
+function getToolCategories() {
+  const cats = {};
+  for (const t of tools) {
+    const cat = t.annotations?.category || '其他';
+    if (!cats[cat]) cats[cat] = { count: 0, tools: [] };
+    cats[cat].count++;
+    cats[cat].tools.push(t.name);
+  }
+  return Object.entries(cats).map(([category, info]) => ({
+    category, count: info.count, tools: info.tools,
+  })).sort((a, b) => b.count - a.count);
+}
+
+async function checkDrawingStandards() {
+  const standards = getDraftingStandards();
+  if (!standards || standards.error) {
+    return { ok: false, error: standards?.error || '制图规范未加载' };
+  }
+  try {
+    const issues = [];
+    for (const rule of standards.layers || []) {
+      const code = `(tblsearch "LAYER" "${escapeLispString(rule.name || rule.pattern)}")`;
+      const exists = await cad.sendCommandWithResult(code);
+      if (rule.required && (!exists || exists === 'nil' || exists === '')) {
+        issues.push({ type: 'missing_layer', message: `缺少必需图层: ${rule.name}` });
+      }
+    }
+    return { ok: issues.length === 0, issues };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
 function getToolRelationships() {
   return {
     selection: {
@@ -1385,6 +1502,12 @@ export async function readResource(uri) {
       return await getDwgContext();
     case 'atlisp://tools/relationships':
       return getToolRelationships();
+    case 'atlisp://dwg/analysis':
+      return await getDrawingAnalysis(params);
+    case 'atlisp://tools/categories':
+      return getToolCategories();
+    case 'atlisp://dwg/standards/check':
+      return await checkDrawingStandards();
     default:
       throw new Error(`资源不存在: ${uri}`);
   }

package/dist/handlers/skill-handlers.js

@@ -0,0 +1,152 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const SKILLS_DIR = path.join(os.homedir(), '.atlisp', 'skills');
+const REGISTRY_URL = process.env.SKILL_REGISTRY_URL || 'https://raw.githubusercontent.com/atlisp/skill-registry/main/index.json';
+const CACHE_PATH = path.join(os.homedir(), '.atlisp', 'skill-registry-cache.json');
+
+function readCache() {
+    try { if (fs.existsSync(CACHE_PATH)) return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf-8')); } catch {}
+    return null;
+}
+
+function writeCache(data) {
+    try { fs.writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2), 'utf-8'); } catch {}
+}
+
+async function fetchIndex() {
+    let index = readCache();
+    if (index && (Date.now() - index.fetchedAt < 3600000)) return index;
+    try {
+        const resp = await fetch(REGISTRY_URL, { headers: { 'User-Agent': 'atlisp-mcp' } });
+        if (resp.ok) {
+            index = await resp.json();
+            index.fetchedAt = Date.now();
+            writeCache(index);
+        }
+    } catch {}
+    return index;
+}
+
+export async function skill_search(a) {
+    const index = await fetchIndex();
+    if (!index?.skills) return { content: [{ type: 'text', text: '无法获取 skill 注册表索引' }], isError: true };
+    const q = (a.query || '').toLowerCase();
+    const results = index.skills.filter(s =>
+        s.name.toLowerCase().includes(q) ||
+        (s.description || '').toLowerCase().includes(q) ||
+        (s.tags || []).some(t => t.toLowerCase().includes(q))
+    );
+    if (!results.length) return { content: [{ type: 'text', text: `未找到匹配 "${a.query}" 的 skill` }] };
+    const lines = [`找到 ${results.length} 个 skill:\n`];
+    for (const s of results) {
+        lines.push(`**${s.name}**`);
+        if (s.description) lines.push(`  描述: ${s.description}`);
+        if (s.tags?.length) lines.push(`  标签: ${s.tags.join(', ')}`);
+        if (s.version) lines.push(`  版本: ${s.version}`);
+        lines.push('');
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+export async function skill_install(a) {
+    if (!a.name) return { content: [{ type: 'text', text: '需要 skill 名称' }], isError: true };
+    const index = await fetchIndex();
+    if (!index?.skills) return { content: [{ type: 'text', text: '无法获取 skill 注册表索引' }], isError: true };
+    const skill = index.skills.find(s => s.name === a.name);
+    if (!skill) return { content: [{ type: 'text', text: `未找到 skill: ${a.name}` }], isError: true };
+    const downloadUrl = skill.download_url || skill.url;
+    if (!downloadUrl) return { content: [{ type: 'text', text: `Skill "${a.name}" 没有下载地址` }], isError: true };
+    let content;
+    try {
+        const resp = await fetch(downloadUrl, { headers: { 'User-Agent': 'atlisp-mcp' } });
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+        content = await resp.text();
+    } catch (e) {
+        return { content: [{ type: 'text', text: `下载失败: ${e.message}` }], isError: true };
+    }
+    try { fs.mkdirSync(SKILLS_DIR, { recursive: true }); } catch {}
+    const safeName = a.name.replace(/[^a-zA-Z0-9\u4e00-\u9fff_-]/g, '-').substring(0, 40);
+    const skillFile = path.join(SKILLS_DIR, `skill-${safeName}.md`);
+    if (fs.existsSync(skillFile)) {
+        return { content: [{ type: 'text', text: `Skill "${a.name}" 已安装 (${skillFile})` }], isError: true };
+    }
+    let finalContent = content;
+    if (!content.match(/^---\n/)) {
+        const tags = (skill.tags || []).join(', ');
+        finalContent = `---\nname: ${a.name}\ndescription: ${skill.description || ''}\ntags: ${tags}\n---\n\n${content}`;
+    }
+    fs.writeFileSync(skillFile, finalContent, 'utf-8');
+    return { content: [{ type: 'text', text: `${skill.name} 安装成功\n文件: ${skillFile}${skill.version ? `\n版本: ${skill.version}` : ''}` }] };
+}
+
+export async function skill_list_installed() {
+    if (!fs.existsSync(SKILLS_DIR)) return { content: [{ type: 'text', text: '暂无已安装的 skill' }] };
+    const results = [];
+    try {
+        const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                const fullPath = path.join(SKILLS_DIR, entry.name);
+                try {
+                    const raw = fs.readFileSync(fullPath, 'utf-8');
+                    const match = raw.match(/^---\n([\s\S]*?)\n---/);
+                    if (match) {
+                        const fm = {};
+                        for (const line of match[1].split('\n')) {
+                            const sep = line.indexOf(':');
+                            if (sep > 0) fm[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+                        }
+                        results.push({ name: fm.name || entry.name.replace('.md', ''), description: fm.description || '', tags: fm.tags || '' });
+                    } else {
+                        results.push({ name: entry.name.replace('.md', ''), description: '', tags: '' });
+                    }
+                } catch {}
+            }
+        }
+    } catch {}
+    if (!results.length) return { content: [{ type: 'text', text: '暂无已安装的 skill' }] };
+    const lines = [`已安装 ${results.length} 个 skill:\n`];
+    for (const s of results) {
+        lines.push(`**${s.name}**${s.description ? ` — ${s.description}` : ''}`);
+        if (s.tags) lines.push(`  标签: ${s.tags}`);
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+
+export async function skill_uninstall(a) {
+    if (!a.name) return { content: [{ type: 'text', text: '需要 skill 名称' }], isError: true };
+    if (!fs.existsSync(SKILLS_DIR)) return { content: [{ type: 'text', text: `未安装 skill: ${a.name}` }], isError: true };
+    let found = null;
+    try {
+        const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                const fullPath = path.join(SKILLS_DIR, entry.name);
+                try {
+                    const raw = fs.readFileSync(fullPath, 'utf-8');
+                    const match = raw.match(/^---\n([\s\S]*?)\n---/);
+                    if (match) {
+                        for (const line of match[1].split('\n')) {
+                            if (line.startsWith('name:') && line.slice(5).trim() === a.name) { found = fullPath; break; }
+                        }
+                    } else if (entry.name.replace('.md', '') === a.name) { found = fullPath; }
+                } catch {}
+                if (found) break;
+            }
+        }
+    } catch {}
+    if (!found) return { content: [{ type: 'text', text: `未安装 skill: ${a.name}` }], isError: true };
+    fs.unlinkSync(found);
+    return { content: [{ type: 'text', text: `${a.name} 已卸载` }] };
+}
+
+export async function skill_list_categories() {
+    const index = await fetchIndex();
+    if (!index?.skills) return { content: [{ type: 'text', text: '无法获取 skill 注册表索引' }], isError: true };
+    const cats = new Set();
+    for (const s of index.skills) for (const t of (s.tags || [])) cats.add(t);
+    const sorted = Array.from(cats).sort();
+    return { content: [{ type: 'text', text: sorted.length ? `注册表分类 (${sorted.length}):\n${sorted.join('\n')}` : '暂无分类' }] };
+}