@atlisp/mcp 1.8.23 → 1.8.26

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/batch-doc-handlers.js

@@ -0,0 +1,242 @@
+import { cad } from '../cad.js';
+import { escapeLispString } from '../handler-utils.js';
+
+function ensureCad() {
+    if (!cad.connected) throw new Error('未连接 CAD');
+}
+
+function esc(s) {
+    return escapeLispString(String(s));
+}
+
+function buildFileList(files) {
+    return files.map(f => `"${esc(f)}"`).join(' ');
+}
+
+export async function batchDocCheckStandards(args) {
+    ensureCad();
+    const { files, requiredLayers, forbiddenLayerPrefixes, requiredTextStyles, requiredDimStyles, maxLayerCount } = args;
+    if (!files?.length) return { content: [{ type: 'text', text: '需要 files 参数' }], isError: true };
+
+    const fileList = buildFileList(files);
+    const reqLayers = (requiredLayers || []).map(l => `"${esc(l)}"`).join(' ');
+    const forPrefixes = (forbiddenLayerPrefixes || []).map(p => `"${esc(p)}"`).join(' ');
+    const reqTStyles = (requiredTextStyles || []).map(s => `"${esc(s)}"`).join(' ');
+    const reqDStyles = (requiredDimStyles || []).map(s => `"${esc(s)}"`).join(' ');
+
+    const lisp = `(progn
+    (vl-load-com)
+    (setq files (list ${fileList}))
+    (setq req-layers (list ${reqLayers}))
+    (setq for-prefixes (list ${forPrefixes}))
+    (setq req-tstyles (list ${reqTStyles}))
+    (setq req-dstyles (list ${reqDStyles}))
+    (setq max-layer ${maxLayerCount || 9999})
+    (setq all-reports (list))
+    (foreach f files
+        (setq report (list (cons "file" f) (cons "ok" T) (cons "issues" (list))))
+        (if (findfile f)
+            (progn
+                (command "._OPEN" f)
+                (setq issues (list))
+                ;; check required layers
+                (foreach l req-layers
+                    (if (not (tblsearch "LAYER" l))
+                        (setq issues (cons (list "missing_layer" (strcat "缺少必需图层: " l)) issues))))
+                ;; check forbidden layer prefixes
+                (setq all-layers (list))
+                (setq i 0)
+                (while (setq e (tblnext "LAYER" (if (= i 0) T nil)))
+                    (setq all-layers (cons (cdr (assoc 2 e)) all-layers))
+                    (setq i (1+ i)))
+                (foreach p for-prefixes
+                    (foreach l all-layers
+                        (if (wcmatch (strcase l) (strcat (strcase p) "*"))
+                            (setq issues (cons (list "forbidden_layer" (strcat "禁止图层前缀: " l " 匹配 " p)) issues)))))
+                ;; check layer count
+                (if (> (length all-layers) max-layer)
+                    (setq issues (cons (list "too_many_layers" (strcat "图层数量 " (itoa (length all-layers)) " 超过限制 " (itoa max-layer))) issues)))
+                ;; check required text styles
+                (foreach s req-tstyles
+                    (if (not (tblsearch "STYLE" s))
+                        (setq issues (cons (list "missing_text_style" (strcat "缺少必需文字样式: " s)) issues))))
+                ;; check required dim styles
+                (foreach s req-dstyles
+                    (if (not (tblsearch "DIMSTYLE" s))
+                        (setq issues (cons (list "missing_dim_style" (strcat "缺少必需标注样式: " s)) issues))))
+                (if issues
+                    (progn
+                        (setq report (cons (cons "ok" nil) report))
+                        (setq report (cons (cons "issues" issues) report)))
+                )
+                (command "_.CLOSE" "_N")
+            )
+            (setq report (cons (cons "ok" nil) (cons (cons "issues" (list (list "file_not_found" "文件不存在"))) report)))
+        )
+        (setq all-reports (cons report all-reports))
+    )
+    (princ all-reports)
+    (princ))
+`;
+
+    try {
+        const raw = await cad.sendCommandWithResult(lisp);
+        let reports;
+        try {
+            reports = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        } catch {
+            reports = [{ file: 'parse_error', ok: false, issues: [{ type: 'parse_error', msg: String(raw).substring(0, 200) }] }];
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(reports, null, 2) }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `批量检查失败: ${e.message}` }], isError: true };
+    }
+}
+
+export async function batchDocFindReplace(args) {
+    ensureCad();
+    const { files, pattern, replacement, caseSensitive, textTypes } = args;
+    if (!files?.length) return { content: [{ type: 'text', text: '需要 files 参数' }], isError: true };
+    if (!pattern) return { content: [{ type: 'text', text: '需要 pattern 参数' }], isError: true };
+
+    const fileList = buildFileList(files);
+    const caseFlag = caseSensitive ? 'nil' : 'T';
+    const types = textTypes || ['ALL'];
+    const textFilter = types.includes('ALL')
+        ? '(cons 0 "TEXT,MTEXT")'
+        : `(cons 0 "${types.join(',')}")`;
+
+    const lisp = `(progn
+    (vl-load-com)
+    (setq files (list ${fileList}))
+    (setq find-pat "${esc(pattern)}")
+    (setq repl-text "${esc(replacement)}")
+    (setq all-results (list))
+    (foreach f files
+        (setq result (list (cons "file" f) (cons "ok" T) (cons "count" 0)))
+        (if (findfile f)
+            (progn
+                (command "._OPEN" f)
+                (setq count 0)
+                (setq ss (ssget "_X" ${textFilter}))
+                (if ss
+                    (progn
+                        (setq i 0)
+                        (while (< i (sslength ss))
+                            (setq e (ssname ss i))
+                            (setq elist (entget e))
+                            (setq old (cdr (assoc 1 elist)))
+                            (if old
+                                (progn
+                                    (setq new (vl-string-subst repl-text find-pat old))
+                                    (if (/= new old)
+                                        (progn
+                                            (setq elist (subst (cons 1 new) (assoc 1 elist) elist))
+                                            (entmod elist)
+                                            (setq count (1+ count))
+                                        )
+                                    )
+                                )
+                            )
+                            (setq i (1+ i))
+                        )
+                    )
+                )
+                (setq result (cons (cons "count" count) result))
+                (command "_.QSAVE")
+                (command "_.CLOSE" "_Y")
+            )
+            (setq result (cons (cons "ok" nil) (cons (cons "error" "文件不存在") result)))
+        )
+        (setq all-results (cons result all-results))
+    )
+    (princ (vl-prin1-to-string all-results))
+    (princ))
+`;
+
+    try {
+        const raw = await cad.sendCommandWithResult(lisp);
+        let results;
+        try {
+            results = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        } catch {
+            results = [{ file: 'parse_error', ok: false, error: String(raw).substring(0, 200) }];
+        }
+        const total = results.reduce((s, r) => s + (r.count || 0), 0);
+        const text = `替换完成: 共处理 ${results.length} 个文件，${total} 处替换\n${JSON.stringify(results, null, 2)}`;
+        return { content: [{ type: 'text', text }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `批量替换失败: ${e.message}` }], isError: true };
+    }
+}
+
+export async function batchDocCleanup(args) {
+    ensureCad();
+    const { files, purgeBlocks, purgeLayers, purgeStyles, runAudit, runOverkill, saveAndClose } = args;
+    if (!files?.length) return { content: [{ type: 'text', text: '需要 files 参数' }], isError: true };
+
+    const fileList = buildFileList(files);
+    const doBlocks = purgeBlocks !== false;
+    const doLayers = purgeLayers !== false;
+    const doStyles = purgeStyles !== false;
+    const doAudit = runAudit !== false;
+
+    const lisp = `(progn
+    (vl-load-com)
+    (setq files (list ${fileList}))
+    (setq all-results (list))
+    (foreach f files
+        (setq result (list (cons "file" f) (cons "ok" T)))
+        (if (findfile f)
+            (progn
+                (command "._OPEN" f)
+                (setq details (list))
+                ;; audit
+                (if ${doAudit}
+                    (progn
+                        (command "_.AUDIT" "_Y")
+                        (setq details (cons "audit_done" details))
+                    )
+                )
+                ;; purge
+                (if ${doBlocks} (command "_.PURGE" "_B" "*" "_N"))
+                (if ${doLayers} (command "_.PURGE" "_LA" "*" "_N"))
+                (if ${doStyles} (command "_.PURGE" "_ST" "*" "_N"))
+                (setq details (cons "purge_done" details))
+                ;; overkill
+                (if ${runOverkill}
+                    (progn
+                        (command "_.OVERKILL" (ssget "_X") "" "_Y")
+                        (setq details (cons "overkill_done" details))
+                    )
+                )
+                (setq result (cons (cons "actions" details) result))
+                (if ${saveAndClose}
+                    (progn
+                        (command "_.QSAVE")
+                        (command "_.CLOSE" "_Y")
+                    )
+                    (command "_.CLOSE" "_N")
+                )
+            )
+            (setq result (cons (cons "ok" nil) (cons (cons "error" "文件不存在") result)))
+        )
+        (setq all-results (cons result all-results))
+    )
+    (princ (vl-prin1-to-string all-results))
+    (princ))
+`;
+
+    try {
+        const raw = await cad.sendCommandWithResult(lisp);
+        let results;
+        try {
+            results = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        } catch {
+            results = [{ file: 'parse_error', ok: false, error: String(raw).substring(0, 200) }];
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+    } catch (e) {
+        return { content: [{ type: 'text', text: `批量清理失败: ${e.message}` }], isError: true };
+    }
+}

package/dist/handlers/cad-handlers.js

@@ -1,3 +1,4 @@
+import iconv from 'iconv-lite';
 import { cad } from '../cad.js';
 import { log } from '../logger.js';
 import { withCadConnection, mcpSuccess, mcpError, escapeLispString } from '../handler-utils.js';
@@ -32,9 +33,15 @@ export const evalLisp = withCadConnection(async (code, withResult = false, encod
     }
 
     if (withResult) {
-        const result = await cad.sendCommandWithResult(trimmed, encoding);
-        if (result !== null) {
-            return mcpSuccess(result);
+        const useRaw = encoding ? true : false;
+        const resp = await cad.sendCommandWithResult(trimmed, encoding, useRaw);
+        if (resp !== null) {
+            if (useRaw && resp.rawBase64) {
+                const buf = Buffer.from(resp.rawBase64, 'base64');
+                const decoded = iconv.decode(buf, encoding);
+                return mcpSuccess(decoded);
+            }
+            return mcpSuccess(resp);
         }
         return mcpError('执行失败或无返回值');
     }

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 = {