@atlisp/cli 1.2.0

package/lib/mcp-client.js

@@ -0,0 +1,203 @@
+const { spawn } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const readline = require("readline");
+
+function resolveMcpCommand() {
+  if (process.platform !== "win32") return { cmd: "npx", args: ["@atlisp/mcp"] };
+  const nodeDir = path.dirname(process.execPath);
+  const npx = path.join(nodeDir, "npx.cmd");
+  if (fs.existsSync(npx)) return { cmd: process.env.COMSPEC || "cmd.exe", args: ["/c", npx, "@atlisp/mcp"] };
+  return { cmd: process.env.COMSPEC || "cmd.exe", args: ["/c", "npx.cmd", "@atlisp/mcp"] };
+}
+
+class McpClient {
+  constructor(cmd, args) {
+    if (cmd) {
+      this.cmd = cmd;
+      this.args = args || [];
+    } else {
+      const resolved = resolveMcpCommand();
+      this.cmd = resolved.cmd;
+      this.args = resolved.args;
+    }
+    this.process = null;
+    this.rl = null;
+    this.pending = new Map();
+    this.nextId = 1;
+  }
+
+  async connect(timeout = 120000) {
+    this.process = spawn(this.cmd, [...this.args, "--stdio", "--security-level", "relaxed"], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process.stderr.on("data", (d) => {
+      const s = d.toString().trim();
+      if (s) process.stderr.write(s + "\n");
+    });
+
+    this.process.on("error", (err) => {
+      for (const [, resolver] of this.pending) {
+        resolver({ error: { message: err.message } });
+      }
+      this.pending.clear();
+    });
+
+    this.process.on("exit", (code) => {
+      for (const [, resolver] of this.pending) {
+        resolver({ error: { message: `MCP process exited with code ${code}` } });
+      }
+      this.pending.clear();
+    });
+
+    this.rl = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity,
+    });
+
+    this.rl.on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        const resolver = this.pending.get(msg.id);
+        if (resolver) {
+          this.pending.delete(msg.id);
+          resolver(msg);
+        }
+      } catch (e) {
+        // ignore malformed lines
+      }
+    });
+
+    const init = await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "atlisp-cli", version: "1.0.0" },
+    }, timeout);
+
+    return init;
+  }
+
+  request(method, params, timeout = 120000) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request "${method}" timed out after ${timeout}ms`));
+      }, timeout);
+      this.pending.set(id, (msg) => {
+        clearTimeout(timer);
+        if (msg.error) reject(new Error(msg.error.message));
+        else resolve(msg.result);
+      });
+      this.process.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    });
+  }
+
+  async callTool(name, args = {}) {
+    return this.request("tools/call", { name, arguments: args });
+  }
+
+  async evalLisp(code, encoding, retries = 3) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        const r = await this._evalRaw(code, encoding);
+        if (r !== "No open document") return r;
+        // "No open document" - wait and retry
+        if (i < retries - 1) {
+          try { await this.callTool("new_document"); } catch (e) { /* ignore */ }
+          await new Promise(r => setTimeout(r, 3000));
+        }
+      } catch (e) {
+        if (i >= retries - 1) throw e;
+        // circuit breaker or other transient error - wait
+        await new Promise(r => setTimeout(r, 3000));
+      }
+    }
+    return null;
+  }
+
+  async ensureDocument(timeout = 120000) {
+    const deadline = Date.now() + timeout;
+    let lastErr = "";
+    while (Date.now() < deadline) {
+      try {
+        const r = await this._evalRaw("(getvar \"dwgname\")");
+        if (r && r !== "No open document" && r.length > 0) {
+          return;
+        }
+        if (r) lastErr = r;
+      } catch (e) {
+        lastErr = e.message;
+      }
+      if (lastErr.includes("No open document")) {
+        try {
+          await this.callTool("new_document");
+        } catch (e) { /* ignore */ }
+      }
+      for (let i = 0; i < 20 && Date.now() < deadline; i++) {
+        try {
+          const r = await this._evalRaw("(getvar \"dwgname\")");
+          if (r && r !== "No open document" && r.length > 0) {
+            return;
+          }
+          if (r) lastErr = r;
+        } catch (e) {
+          lastErr = e.message;
+        }
+        await new Promise(r => setTimeout(r, 500));
+      }
+    }
+    throw new Error("CAD 文档就绪超时: " + lastErr);
+  }
+
+  async _evalRaw(code, encoding) {
+    const args = { code };
+    if (encoding) args.encoding = encoding;
+    const result = await this.callTool("eval_lisp_with_result", args);
+    if (result && result.content && result.content.length > 0) {
+      return result.content.map((c) => c.text).join("\n");
+    }
+    return JSON.stringify(result);
+  }
+
+  async evalLisp(code, encoding, retries = 3) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        const r = await this._evalRaw(code, encoding);
+        if (r !== "No open document") return r;
+        // "No open document" - wait and retry
+        if (i < retries - 1) {
+          try { await this.callTool("new_document"); } catch (e) { /* ignore */ }
+          await new Promise(r => setTimeout(r, 2000));
+        }
+      } catch (e) {
+        if (i >= retries - 1) throw e;
+        // circuit breaker or other transient error - wait
+        await new Promise(r => setTimeout(r, 2000));
+      }
+    }
+    return null;
+  }
+
+  async disconnect() {
+    if (this.process) {
+      try { this.process.stdin.end(); } catch (e) { /* ignore */ }
+      try { this.process.kill(); } catch (e) { /* ignore */ }
+      this.process = null;
+      this.rl = null;
+    }
+  }
+}
+
+async function withMcp(fn) {
+  const mcp = new McpClient();
+  try {
+    await mcp.connect();
+    return await fn(mcp);
+  } finally {
+    await mcp.disconnect();
+  }
+}
+
+module.exports = { McpClient, withMcp };

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@atlisp/cli",
+    "version": "1.2.0",
+    "description": "@lisp CLI — 在 AutoCAD/ZWCAD/GStarCAD/BricsCAD 中管理 AutoLISP 包、构建内核、运行测试",
+    "main": "index.js",
+    "bin": {
+        "atlisp": "atlisp.js",
+        "atlisp-node": "atlisp.js"
+    },
+    "scripts": {
+        "test": "jest",
+        "start": "node atlisp.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://gitee.com/atlisp/atlisp-cli"
+    },
+    "homepage": "https://atlisp.cn",
+    "keywords": ["atlisp", "@lisp", "CAD", "autolisp", "autocad", "zwcad", "gstarcad", "bricscad"],
+    "author": "VitalGG",
+    "license": "ISC",
+    "engines": { "node": ">=18" },
+    "dependencies": {
+        "@atlisp/lint": "^0.2.8",
+        "chalk": "^4.1.2",
+        "figlet": "^1.8.0",
+        "inquirer": "^8.2.6",
+        "node-fetch": "^3.3.2",
+        "qrcode": "^1.5.4",
+        "ssh2": "^1.17.0"
+    },
+    "devDependencies": {
+        "jest": "^29.7.0",
+        "nock": "^13.5.6"
+    },
+    "jest": {
+        "collectCoverage": true,
+        "coverageThreshold": {
+            "global": {
+                "branches": 15,
+                "functions": 25,
+                "lines": 25,
+                "statements": 25
+            }
+        },
+        "coverageReporters": ["text", "lcov", "clover"],
+        "testMatch": ["**/__tests__/**/*.test.js"]
+    }
+}

package/scripts/add-deps.js

@@ -0,0 +1,81 @@
+/**
+ * Script to add @depends annotations to all kernel source files.
+ * Run: node scripts/add-deps.js
+ */
+const fs = require("fs");
+const path = require("path");
+
+const { getKernelSrc } = require("../lib/common");
+const KERNEL_SRC = getKernelSrc();
+const KERNEL_ORDER = (() => { try { return require("../kernel-order.json"); } catch(e) { return []; } })();
+
+const KNOWN_DEPS = {
+  "compat-cl.lsp":              ["compat-cl"],
+  "platform-api.lsp":           ["platform-api"],
+  "lib/string-utils.lsp":       ["string-utils"],
+  "lib/version.lsp":            ["string-utils", "version"],
+  "lib/file-utils.lsp":         ["string-utils", "file-utils"],
+  "lib/dcl.lsp":                ["string-utils", "file-utils", "dcl"],
+  "event-bus.lsp":              ["event-bus"],
+  "base-function.lsp":          ["event-bus", "platform-api", "base-function"],
+  "platform.lsp":               ["platform-api", "base-function"],
+  "version.lsp":                ["version"],
+  "bootstrap.lsp":              ["platform", "version", "base-function"],
+  "error-handle.lsp":           ["base-function", "platform", "error-handle"],
+  "log.lsp":                    ["error-handle", "log"],
+  "i18n.lsp":                   ["log", "i18n"],
+  "net.lsp":                    ["log", "event-bus", "base-function", "net"],
+  "functionlib.lsp":            ["net", "functionlib"],
+  "@lisp-env.lsp":              ["functionlib"],
+  "setup.lsp":                  ["@lisp-env", "net"],
+  "sub-system/help-system.lsp": ["base-function", "i18n"],
+  "sub-system/config-manager.lsp": ["base-function", "i18n"],
+  "sub-system/ui.lsp":          ["base-function", "config-manager"],
+  "sub-system/voice.lsp":       ["base-function"],
+  "sub-system/package-manager.lsp": ["base-function", "net", "config-manager", "i18n"],
+  "sub-system/user-manager.lsp": ["base-function", "net", "config-manager"],
+  "sub-system/update.lsp":      ["base-function", "net", "config-manager"],
+  "sub-system/condition.lsp":   ["base-function", "net", "i18n"],
+  "sub-system/cache.lsp":       ["base-function", "file-utils"],
+  "sub-system/scheduler.lsp":   ["base-function", "event-bus"],
+  "sub-system/config-sync.lsp": ["base-function", "net", "config-manager"],
+  "sub-system/config/config.lsp":                 ["sub-system/config-manager", "i18n"],
+  "sub-system/command.lsp":                ["config", "base-function"],
+  "init.lsp":                   ["command", "setup", "bootstrap"],
+};
+
+const DEPENDS_RE = /;;\s*@depends\s+/;
+const PROVIDES_RE = /;;\s*@provides\s+/;
+
+let changed = 0;
+
+for (const f of KERNEL_ORDER) {
+  const fullPath = path.join(KERNEL_SRC, f);
+  if (!fs.existsSync(fullPath)) {
+    console.error(`Missing: ${f}`);
+    continue;
+  }
+  const content = fs.readFileSync(fullPath, "utf-8");
+  const firstLines = content.split("\n");
+  const hasDepends = firstLines.some(l => DEPENDS_RE.test(l));
+  const hasProvides = firstLines.some(l => PROVIDES_RE.test(l));
+
+  if (hasDepends) {
+    console.log(`  ✓ ${f} (already has @depends)`);
+    continue;
+  }
+
+  const deps = KNOWN_DEPS[f];
+  if (!deps || deps.length === 0) {
+    console.log(`  - ${f} (no deps)`);
+    continue;
+  }
+
+  const annotation = `;; @depends ${deps.join(" ")}`;
+  const newContent = annotation + "\n" + content;
+  fs.writeFileSync(fullPath, newContent, "utf-8");
+  console.log(`  + ${f} → added: ${annotation}`);
+  changed++;
+}
+
+console.log(`\nUpdated ${changed} files with @depends annotations.`);

package/scripts/fix-deps.js

@@ -0,0 +1,98 @@
+const fs = require("fs");
+const path = require("path");
+
+const { getKernelSrc } = require("../lib/common");
+const KERNEL_SRC = getKernelSrc();
+const KERNEL_ORDER = (() => { try { return require("../kernel-order.json"); } catch(e) { return []; } })();
+
+const CORRECT_DEPS = {
+  // lib/* files are development sources extracted from base-function.lsp
+  // They @provide their own feature, only depending on core CL/compat
+  "lib/string-utils.lsp": { provides: ["string-utils"], deps: [] },
+  "lib/version.lsp":      { provides: ["version-utils"], deps: ["string-utils"] },
+  "lib/file-utils.lsp":   { provides: ["file-utils"], deps: ["string-utils"] },
+  "lib/dcl.lsp":          { provides: ["dcl"], deps: ["string-utils", "file-utils"] },
+
+  // Core files
+  "compat-cl.lsp":        { provides: ["compat-cl"], deps: [] },
+  "platform-api.lsp":     { provides: ["platform-api"], deps: [] },
+  "event-bus.lsp":        { provides: ["event-bus"], deps: [] },
+  "base-function.lsp":    { provides: ["base-function"], deps: ["event-bus", "platform-api"] },
+  "platform.lsp":         { provides: ["platform"], deps: ["platform-api", "base-function"] },
+  "version.lsp":          { provides: ["version"], deps: [] },
+  "bootstrap.lsp":        { provides: ["bootstrap"], deps: ["platform", "version", "base-function"] },
+  "error-handle.lsp":     { provides: ["error-handle"], deps: ["base-function", "platform"] },
+  "log.lsp":              { provides: ["log"], deps: ["error-handle"] },
+  "i18n.lsp":             { provides: ["i18n"], deps: ["log"] },
+  "net.lsp":              { provides: ["net"], deps: ["log", "event-bus", "base-function"] },
+  "functionlib.lsp":      { provides: ["functionlib"], deps: ["net"] },
+  "@lisp-env.lsp":        { provides: ["@lisp-env"], deps: ["functionlib"] },
+  "setup.lsp":            { provides: ["setup"], deps: ["@lisp-env", "net"] },
+
+  // Sub-systems
+  "sub-system/help-system.lsp":      { provides: ["help-system"], deps: ["base-function", "i18n"] },
+  "sub-system/config-manager.lsp":   { provides: ["config-manager"], deps: ["base-function", "i18n"] },
+  "sub-system/ui.lsp":               { provides: ["ui"], deps: ["base-function", "config-manager"] },
+  "sub-system/voice.lsp":            { provides: ["voice"], deps: ["base-function"] },
+  "sub-system/package-manager.lsp":  { provides: ["package-manager"], deps: ["base-function", "net", "config-manager", "i18n"] },
+  "sub-system/user-manager.lsp":     { provides: ["user-manager"], deps: ["base-function", "net", "config-manager"] },
+  "sub-system/update.lsp":           { provides: ["update"], deps: ["base-function", "net", "config-manager"] },
+  "sub-system/condition.lsp":        { provides: ["condition"], deps: ["base-function", "net", "i18n"] },
+  "sub-system/cache.lsp":            { provides: ["cache"], deps: ["base-function", "file-utils"] },
+  "sub-system/scheduler.lsp":        { provides: ["scheduler"], deps: ["base-function", "event-bus"] },
+  "sub-system/config-sync.lsp":      { provides: ["config-sync"], deps: ["base-function", "net", "config-manager"] },
+  "sub-system/audit.lsp":            { provides: ["audit"], deps: ["config-manager", "net", "file-utils", "base-function"] },
+  "sub-system/permission.lsp":       { provides: ["permission"], deps: ["config-manager", "net", "base-function"] },
+
+  // Final files
+  "sub-system/config/config.lsp":  { provides: ["config"], deps: ["config-manager", "i18n"] },
+  "sub-system/command.lsp": { provides: ["command"], deps: ["config", "base-function"] },
+  "init.lsp":    { provides: ["init"], deps: ["command", "setup", "bootstrap"] },
+};
+
+const DEPENDS_RE = /;;\s*@depends\s+/;
+const PROVIDES_RE = /;;\s*@provides\s+/;
+
+function stripAnnotation(content) {
+  const lines = content.split("\n");
+  const filtered = lines.filter(l => !DEPENDS_RE.test(l) && !PROVIDES_RE.test(l));
+  return filtered.join("\n");
+}
+
+let changed = 0;
+
+for (const f of KERNEL_ORDER) {
+  const fullPath = path.join(KERNEL_SRC, f);
+  if (!fs.existsSync(fullPath)) {
+    console.error(`Missing: ${f}`);
+    continue;
+  }
+
+  const info = CORRECT_DEPS[f];
+  if (!info) {
+    console.log(`  - ${f} (no dep info)`);
+    continue;
+  }
+
+  const content = fs.readFileSync(fullPath, "utf-8");
+  const clean = stripAnnotation(content);
+
+  const parts = [];
+  if (info.deps.length > 0) {
+    parts.push(`;; @depends ${info.deps.join(" ")}`);
+  }
+  if (info.provides.length > 0) {
+    parts.push(`;; @provides ${info.provides.join(" ")}`);
+  }
+
+  if (parts.length > 0) {
+    const newContent = parts.join("\n") + "\n" + clean;
+    if (newContent !== content) {
+      fs.writeFileSync(fullPath, newContent, "utf-8");
+      console.log(`  + ${f} → ${parts.join("; ")}`);
+      changed++;
+    }
+  }
+}
+
+console.log(`\nUpdated ${changed} files.`);