@atlisp/cli 1.2.0

package/commands/publish.js

@@ -0,0 +1,237 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const common = require("../lib/common");
+const { buildModule } = require("./build");
+
+const { getKernelSrc } = require("../lib/common");
+const KERNEL_SRC = getKernelSrc();
+const MODULES_SRC = path.join(KERNEL_SRC, "modules");
+
+
+async function cmdPublishModule(filePath, opts) {
+  const moduleName = opts.name || path.basename(filePath, ".lsp");
+  const edition = opts.edition || "stable";
+  const uploadUrl = opts.server || "https://atlisp.cn/upload-module";
+
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(chalk.red(`错误: 找不到文件 ${absPath}`));
+    process.exit(1);
+  }
+
+  const versionFile = path.join(KERNEL_SRC, "version.lsp");
+  let version = opts.version;
+  if (!version && fs.existsSync(versionFile)) {
+    const verContent = fs.readFileSync(versionFile, "utf-8");
+    const m = verContent.match(/"([^"]+)"/);
+    if (m) version = m[1];
+  }
+
+  const cfg = common.readConfigCfg();
+  const json = common.readAtlispConfig();
+  const email = opts.email || cfg.userEmail || json["user-email"];
+  const token = opts.token || cfg.userToken || json["user-token"];
+  if (!email || !token) {
+    console.error(chalk.red("错误: 未设置 user-email 和 user-token。"));
+    console.error(chalk.gray("请先在 CAD 中用 @login 命令登录，"));
+    console.error(chalk.gray("或在 ~/.atlisp/atlisp.json 中配置，或用 --email / --token 参数提供。"));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan("正在构建模块..."));
+  buildModule(moduleName);
+
+  console.log(chalk.cyan(`正在发布模块: ${moduleName} (${edition})`));
+  console.log(chalk.gray(`  文件: ${absPath}`));
+
+  const content = fs.readFileSync(absPath, "utf-8");
+  const hash = common.computeChecksum(content.replace(/\n;; @checksum: -?\d+\s*$/, ""));
+  console.log(chalk.gray(`  checksum: ${hash}`));
+
+  const boundary = "----AtlispFormBoundary" + Date.now();
+  const filename = moduleName + ".lsp";
+  const header = [
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="email"\r\n\r\n`,
+    `${email}\r\n`,
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="token"\r\n\r\n`,
+    `${token}\r\n`,
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="module-name"\r\n\r\n`,
+    `${moduleName}\r\n`,
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="edition"\r\n\r\n`,
+    `${edition}\r\n`,
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="version"\r\n\r\n`,
+    `${version || ""}\r\n`,
+    `--${boundary}\r\n`,
+    `Content-Disposition: form-data; name="file"; filename="${filename}"\r\n`,
+    `Content-Type: application/octet-stream\r\n\r\n`,
+  ].join("");
+  const footer = `\r\n--${boundary}--\r\n`;
+  const bodyBuffer = Buffer.concat([
+    Buffer.from(header, "utf-8"),
+    Buffer.from(content, "utf-8"),
+    Buffer.from(footer, "utf-8"),
+  ]);
+
+  const urlObj = new URL(uploadUrl);
+  const https = require("https");
+  const options = {
+    hostname: urlObj.hostname,
+    port: urlObj.port || 443,
+    path: urlObj.pathname,
+    method: "POST",
+    headers: {
+      "Content-Type": `multipart/form-data; boundary=${boundary}`,
+      "Content-Length": bodyBuffer.length,
+    },
+  };
+
+  console.log(chalk.gray(`  POST ${uploadUrl}`));
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        if (res.statusCode === 200) {
+          try {
+            const parsed = data.match(/:result\s*\.\s*([^)\s]+)/);
+            const success = parsed && parsed[1] === "T";
+            const msgMatch = data.match(/:msg\s*\.\s*"([^"]*)"/);
+            const msg = msgMatch ? msgMatch[1] : data.trim();
+            if (success) {
+              console.log(chalk.green(`✓ 模块 ${moduleName} 已发布到 ${edition}`));
+              console.log(chalk.gray(`  服务端: ${msg}`));
+              resolve(true);
+            } else {
+              console.error(chalk.red(`✗ 发布失败: ${msg}`));
+              resolve(false);
+            }
+          } catch (e) {
+            console.error(chalk.red(`✗ 响应解析失败: ${data.trim()}`));
+            resolve(false);
+          }
+        } else {
+          console.error(chalk.red(`✗ HTTP ${res.statusCode}: ${data.trim()}`));
+          resolve(false);
+        }
+      });
+    });
+    req.on("error", (err) => {
+      console.error(chalk.red(`✗ 网络错误: ${err.message}`));
+      resolve(false);
+    });
+    req.write(bodyBuffer);
+    req.end();
+  });
+}
+
+async function cmdDeploy() {
+  const { Client } = require("ssh2");
+  const host = "dev.atlisp.cn";
+  const user = "vitalgg";
+  const remoteDir = "www/@lisp/modules/stable/";
+  const keyPath = path.join(os.homedir(), ".ssh", "id_rsa");
+
+  if (!fs.existsSync(keyPath)) {
+    console.error(chalk.red(`SSH 密钥不存在: ${keyPath}`));
+    console.log(chalk.gray("请确保 ~/.ssh/id_rsa 存在并可访问 dev.atlisp.cn"));
+    process.exit(1);
+  }
+
+  const modulesDir = MODULES_SRC;
+  const files = fs.readdirSync(modulesDir)
+    .filter(f => f.endsWith(".lsp"))
+    .sort();
+  if (files.length === 0) {
+    console.log(chalk.yellow("没有找到模块文件"));
+    return;
+  }
+
+  console.log(chalk.cyan(`\n部署 ${files.length} 个模块到 ${user}@${host}:${remoteDir}\n`));
+
+  const conn = new Client();
+  await new Promise((resolve, reject) => {
+    conn.on("ready", resolve);
+    conn.on("error", reject);
+    conn.connect({ host, port: 22, username: user, privateKey: fs.readFileSync(keyPath, "utf8") });
+  });
+
+  return new Promise((resolve) => {
+    conn.sftp((err, sftp) => {
+      if (err) {
+        console.error(chalk.red("SFTP 连接失败: " + err.message));
+        conn.end();
+        process.exit(1);
+        return;
+      }
+
+      let ok = 0, fail = 0;
+      let idx = 0;
+
+      const next = () => {
+        if (idx >= files.length) {
+          sftp.end();
+          conn.end();
+          console.log(chalk.cyan(`\n完成: ${ok} 成功, ${fail} 失败\n`));
+          resolve();
+          if (fail > 0) process.exit(1);
+          return;
+        }
+
+        const f = files[idx++];
+        const src = path.join(modulesDir, f);
+        const remote = remoteDir + f;
+        process.stdout.write(chalk.gray(`  ${f} ... `));
+
+        sftp.fastPut(src, remote, (err) => {
+          if (err) {
+            console.log(chalk.red("✗ " + err.message));
+            fail++;
+          } else {
+            console.log(chalk.green("✓"));
+            ok++;
+          }
+          next();
+        });
+      };
+
+      next();
+    });
+  });
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  const opts = {};
+  let val = args[1];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const key = args[i].slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const v = args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : true;
+      if (v !== true) i++;
+      opts[key] = v;
+    } else if (val === args[1]) {
+      val = args[i];
+    }
+  }
+  if (cmd === "deploy") {
+    await cmdDeploy();
+  } else {
+    const filePath = val || "";
+    await cmdPublishModule(filePath, opts);
+  }
+}
+
+function register(reg) {
+  reg("publish-module", handler, ["pm"]);
+  reg("deploy", handler);
+}
+
+module.exports = { register };

package/commands/pull.js

@@ -0,0 +1,118 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const common = require("../lib/common");
+const cad = require("../lib/cad");
+
+async function cmdPull(pkgName, opts) {
+  if (!pkgName) {
+    console.error(chalk.red("错误: 请指定包名。用法: atlisp pull <包名> [--auto] [--download]"));
+    process.exit(1);
+  }
+  if (opts && opts.download) {
+    console.log(chalk.cyan("\n下载包 \"" + pkgName + "\"...\n"));
+    try {
+      const text = await common.httpGet("/packages-list?edition=stable");
+      if (text && text.length > 0) {
+        const pkgs = common.parsePackages(text);
+        const match = pkgs.find(p => p.name === pkgName.toLowerCase());
+        if (match) {
+          const apiBase = common.API_BASE;
+          const dest = path.join(os.homedir(), "@lisp", "packages", pkgName);
+          console.log(chalk.cyan("包名: ") + match.fullName);
+          console.log(chalk.cyan("描述: ") + (match.description || "(无)"));
+          console.log(chalk.cyan("分类: ") + (match.category || "未分类"));
+          console.log(chalk.cyan("下载到: ") + dest);
+          fs.mkdirSync(dest, { recursive: true });
+          const pkgLspUrl = `${apiBase}/${pkgName}/pkg.lsp`;
+          try {
+            const resp = await fetch(pkgLspUrl);
+            if (resp.ok) {
+              const content = await resp.text();
+              fs.writeFileSync(path.join(dest, "pkg.lsp"), content, "utf-8");
+              console.log(chalk.gray("  ✓ pkg.lsp"));
+              const files = (content.match(/:files\s+\(([^)]*)\)/i) || [])[1];
+              if (files) {
+                const fileList = files.split(/\s+/).filter(Boolean);
+                for (const f of fileList) {
+                  const fUrl = `${apiBase}/${pkgName}/${f}.lsp`;
+                  const fResp = await fetch(fUrl);
+                  if (fResp.ok) {
+                    const fContent = await fResp.text();
+                    fs.writeFileSync(path.join(dest, f + ".lsp"), fContent, "utf-8");
+                    console.log(chalk.gray(`  ✓ ${f}.lsp`));
+                  } else {
+                    const fasResp = await fetch(`${apiBase}/${pkgName}/${f}.fas`);
+                    if (fasResp.ok) {
+                      const buf = Buffer.from(await fasResp.arrayBuffer());
+                      fs.writeFileSync(path.join(dest, f + ".fas"), buf);
+                      console.log(chalk.gray(`  ✓ ${f}.fas`));
+                    }
+                  }
+                }
+              }
+              console.log(chalk.green("\n✓ 下载完成"));
+            } else {
+              console.log(chalk.yellow("  服务器上未找到该包的文件"));
+            }
+          } catch (e) {
+            console.error(chalk.red("  ✗ 下载文件失败: " + e.message));
+          }
+          console.log(chalk.gray("\n使用 --auto 参数可直接安装到 CAD:"));
+          console.log(chalk.gray("  atlisp pull " + pkgName + " --auto\n"));
+          return;
+        }
+      }
+      console.log(chalk.yellow("未找到包: " + pkgName));
+    } catch (err) {
+      console.error(chalk.red("下载失败: " + err.message));
+    }
+    return;
+  }
+  if (!opts || !opts.auto) {
+    console.log("\n安装 @lisp 应用包 \"" + pkgName + "\" 到 CAD...");
+    console.log("复制以下代码到CAD命令行:\n");
+    console.log(common.pullLispCode(pkgName));
+    console.log("\n或使用 --auto 参数自动安装（仅 Windows）:");
+    console.log("  atlisp pull " + pkgName + " --auto");
+    return;
+  }
+  console.log("\n自动安装 \"" + pkgName + "\" 到 CAD...");
+  await cad.pull(pkgName, opts.app, opts.profile);
+}
+
+async function cmdRemove(pkgName, opts) {
+  if (!pkgName) {
+    console.error(chalk.red("错误: 请指定包名。用法: atlisp remove <包名> [--auto]"));
+    process.exit(1);
+  }
+  if (!opts || !opts.auto) {
+    console.log("\n卸载 @lisp 应用包 \"" + pkgName + "\"...");
+    console.log("复制以下代码到CAD命令行:\n");
+    console.log(common.removeLispCode(pkgName));
+    console.log("\n或使用 --auto 参数自动卸载（仅 Windows）:");
+    console.log("  atlisp remove " + pkgName + " --auto");
+    return;
+  }
+  console.log("\n自动卸载 \"" + pkgName + "\"...");
+  await cad.remove(pkgName, opts.app, opts.profile);
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  const val = args[1];
+  const opts = common.parseArgs(args.slice(1));
+  if (cmd === "remove" || cmd === "rm") {
+    await cmdRemove(val, opts);
+  } else {
+    await cmdPull(val, opts);
+  }
+}
+
+function register(reg) {
+  reg("pull", (args) => cmdPull(args[0], common.parseArgs(args.slice(1))), ["p"]);
+  reg("remove", (args) => cmdRemove(args[0], common.parseArgs(args.slice(1))), ["rm"]);
+}
+
+module.exports = { register };

package/commands/qrcode.js

@@ -0,0 +1,33 @@
+const chalk = require("chalk");
+const QRCode = require("qrcode");
+
+async function cmdQRCode(text, ascii) {
+  if (!text) {
+    console.error(chalk.red("请指定文本: atlisp qrcode <文本>"));
+    process.exit(1);
+  }
+  try {
+    const opts = { type: ascii ? "ascii" : "terminal", small: ascii ? false : true };
+    const qr = await QRCode.toString(text, opts);
+    console.log("\n" + qr);
+    console.log(chalk.cyan("QR 码内容: ") + text + "\n");
+  } catch (err) {
+    console.error(chalk.red("QR 码生成失败: " + err.message));
+    process.exit(1);
+  }
+}
+
+async function handler(args) {
+  if (args[0] === "qrcode-ascii" || args[0] === "qra") {
+    await cmdQRCode(args[1], true);
+  } else {
+    await cmdQRCode(args[1], false);
+  }
+}
+
+function register(reg) {
+  reg("qrcode", (args) => cmdQRCode(args[0], false), ["qr"]);
+  reg("qrcode-ascii", (args) => cmdQRCode(args[0], true), ["qra"]);
+}
+
+module.exports = { register };

package/commands/test.js

@@ -0,0 +1,223 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const { execSync } = require("child_process");
+const common = require("../lib/common");
+const KERNEL_SRC = common.getKernelSrc();
+const TEST_DIR = common.getKernelTest();
+const KERNEL_ORDER = (() => {
+  try { return require("../kernel-order.json"); }
+  catch (e) { return []; }
+})();
+
+async function cmdTest(filter, opts) {
+  const testDir = path.join(__dirname, "..", "..", "..", "..", "test");
+  const srcDir = KERNEL_SRC;
+
+  if (opts && opts.load) {
+    const kernelFiles = KERNEL_ORDER;
+    if (opts.list) {
+      console.log(chalk.gray("\n内核源文件加载测试列表:\n"));
+      kernelFiles.forEach(f => console.log(`  ${chalk.cyan(f)}`));
+      console.log(chalk.gray(`\n共 ${kernelFiles.length} 个文件`));
+      return;
+    }
+
+    const platform = (opts && opts.platform) || "sbcl";
+
+    if (platform === "sbcl") {
+      console.log(chalk.blue("\n=== @lisp Kernel 加载测试 (SBCL) ==="));
+      console.log(chalk.gray(`\n共 ${kernelFiles.length} 个内核源文件需要验证。`));
+      console.log(chalk.gray("SBCL 仅做语法检查。使用 --platform cad 在 CAD 中逐个加载验证。\n"));
+      let ok = 0, fail = 0;
+      for (const f of kernelFiles) {
+        const filePath = path.join(srcDir, f);
+        if (!fs.existsSync(filePath)) {
+          console.log(`  ${chalk.red("✗")} ${f} ${chalk.red("(文件不存在)")}`);
+          fail++;
+        } else {
+          console.log(`  ${chalk.green("✓")} ${f}`);
+          ok++;
+        }
+      }
+      console.log(chalk.gray(`\n${ok} 存在, ${fail} 缺失\n`));
+      return;
+    }
+
+    if (platform === "cad") {
+      if (opts && opts.manual) {
+        console.log(chalk.blue("\n=== @lisp Kernel 加载测试 (CAD) ===\n"));
+        console.log(chalk.gray("请在 CAD 中加载测试脚本并执行:\n"));
+        console.log(`  (load "${testDir.replace(/\\/g, "/")}/test-load.lsp")`);
+        console.log(`  (@::load-test "${srcDir.replace(/\\/g, "/")}/")\n`);
+        console.log(chalk.gray(`共 ${kernelFiles.length} 个源文件，将逐个加载验证。`));
+        return;
+      }
+      const loadPath = path.join(testDir, "test-load.lsp").replace(/\\/g, "/");
+      const srcPath = srcDir.replace(/\\/g, "/") + "/";
+      const lispCode = `(load "${loadPath}")(@::load-test "${srcPath}")`;
+      console.log(chalk.blue("\n正在通过 MCP 向 CAD 发送加载测试...\n"));
+      try {
+        const output = await withMcp(async (mcp) => {
+          await mcp.ensureDocument();
+          return await mcp.evalLisp(lispCode);
+        });
+        console.log(chalk.green("  ✓ 加载测试完成"));
+        if (output) console.log(output);
+      } catch (e) {
+        console.error(chalk.red(`  ✗ ${e.message}`));
+        if (e.message.includes("ENOENT") || e.message.includes("spawn")) {
+          console.log(chalk.yellow("\natlisp-mcp 未安装。请执行:\n"));
+          console.log(chalk.cyan("  npm install -g @atlisp/mcp\n"));
+          console.log(chalk.gray("或用 --manual 模式手动在 CAD 中执行测试:\n"));
+          console.log(chalk.gray("  node atlisp.js test --load --platform cad --manual\n"));
+        }
+        process.exit(1);
+      }
+    }
+    return;
+  }
+
+  if (opts && opts.list) {
+    console.log(chalk.gray("测试文件列表:"));
+    const files = fs.readdirSync(testDir).filter(f => f.startsWith("test-") && f.endsWith(".lsp"));
+    files.forEach(f => {
+      const content = fs.readFileSync(path.join(testDir, f), "utf-8");
+      const desc = (content.match(/;; @lisp\s+(.+)/) || [])[1] || "";
+      console.log(`  ${chalk.cyan(f)}  ${chalk.gray(desc)}`);
+    });
+    return;
+  }
+
+  const platform = (opts && opts.platform) || "sbcl";
+  const testFiles = fs.readdirSync(testDir)
+    .filter(f => f.startsWith("test-") && f.endsWith(".lsp") && f !== "test-runner.lsp" && f !== "test-load.lsp")
+    .sort();
+
+  const filtered = filter
+    ? testFiles.filter(f => f.includes(filter))
+    : testFiles;
+
+  if (filtered.length === 0) {
+    console.log(chalk.yellow("没有匹配的测试文件。"));
+    return;
+  }
+
+  console.log(chalk.blue(`\n=== @lisp Test Runner (${platform}) ===\n`));
+
+  if (platform === "sbcl") {
+    try {
+      require("child_process").execSync("sbcl --version", { encoding: "utf-8" });
+    } catch (e) {
+      console.log(chalk.yellow("SBCL not found. Run tests in CAD:"));
+      console.log("  (load "+ path.join(testDir, "run-all.lsp").replace(/\\/g, "/") + ")");
+      console.log("  (@::run-tests)");
+      return;
+    }
+    console.log(chalk.cyan("SBCL mode: syntax validation only. Use --platform cad to run tests."));
+    console.log(chalk.gray("AutoLISP tests require a CAD environment with VL functions."));
+    return;
+  }
+
+  if (platform === "cad") {
+    if (opts && opts.manual) {
+      console.log(chalk.gray("请在 CAD 命令行中执行:"));
+      console.log(`  (load "${testDir.replace(/\\/g, "/")}/test-runner.lsp")`);
+      filtered.forEach(f => console.log(`  (load "${path.join(testDir, f).replace(/\\/g, "/")}")`));
+      console.log(`  (@::run-tests nil)`);
+      return;
+    }
+    console.log(chalk.blue("\n正在通过 MCP 向 CAD 发送测试...\n"));
+    try {
+      const output = await withMcp(async (mcp) => {
+        await mcp.ensureDocument();
+        const _modDir = path.join(srcDir, "modules").replace(/\\/g, "/");
+        const _runnerPath = path.join(testDir, "test-runner.lsp").replace(/\\/g, "/");
+        const _lispDir = path.join(os.homedir(), "@lisp").replace(/\\/g, "/");
+        console.log(chalk.gray("  1/8 Loading @lisp kernel via file content..."));
+        const kernelRaw = fs.readFileSync(path.join(os.homedir(), "@lisp", "@lisp_u.lsp"), "utf-8");
+        await mcp.evalLisp(kernelRaw);
+        console.log(chalk.gray("  2/8 Setting up environment + modules + runner..."));
+        const _stubsPath = path.join(testDir, "test-stubs.lsp").replace(/\\/g, "/");
+        const _modNetworkRaw = fs.readFileSync(path.join(srcDir, "modules", "network.lsp"), "utf-8");
+        const _modPkgmanRaw = fs.readFileSync(path.join(srcDir, "modules", "pkgman.lsp"), "utf-8");
+        const _stubsRaw = fs.readFileSync(path.join(testDir, "test-stubs.lsp"), "utf-8");
+        const _runnerRaw = fs.readFileSync(path.join(testDir, "test-runner.lsp"), "utf-8");
+        const setupCode = `
+(setq @::*offline-mode-p* T @::*dev-mode* T)
+(defun @::internetp () (princ "nop") nil)
+(if (null @::*prefix*) (setq @::*prefix* (strcat $userhome "/@lisp/")))
+(setq @::*prefix-config* (strcat @::*prefix* ".atlisp/"))
+(setq @::*cache-dir* (strcat @::*prefix* ".cache/"))
+(vl-mkdir @::*cache-dir*)
+(setq @::agent-uri "http://localhost:8211")
+${_modNetworkRaw}
+${_modPkgmanRaw}
+${_stubsRaw}
+${_runnerRaw}
+(if @::*prefix* (strcat "prefix=" @::*prefix*) "prefix=NIL")
+`;
+        const setupResult = await mcp.evalLisp(setupCode);
+        if (setupResult) {
+          if (setupResult.includes("prefix=")) {
+            const prefixMatch = setupResult.match(/prefix=([^\s]+)/);
+            console.log(chalk.gray(`    ${prefixMatch ? 'prefix='+prefixMatch[1] : setupResult.substring(0, 80)}`));
+          } else if (setupResult.includes("MISSING") || setupResult.includes("error")) {
+            console.log(chalk.yellow(`    Setup issue: ${setupResult.substring(0, 100)}`));
+          }
+        }
+        console.log(chalk.gray(`  6/8 Loading ${filtered.length} test files (batched)...`));
+        // Load ALL test files in a SINGLE evalLisp call to survive circuit breaker resets
+        const loadExpr = `(setq @::*test-runner-tests* nil)\n(in-package :@)\n` + filtered.map(f =>
+          fs.readFileSync(path.join(testDir, f), "utf-8")).join("\n\n");
+        const loadResult = await mcp.evalLisp(loadExpr);
+        if (loadResult && (loadResult.includes("error") || loadResult.includes("Error")
+            || loadResult.includes("ERROR") || loadResult.includes("no function"))) {
+          console.log(chalk.yellow(`    Some files had errors (first 200 chars): ${loadResult.substring(0, 200)}`));
+        }
+        console.log(chalk.gray(`  7/8 Waiting for CAD...`));
+        await new Promise(r => setTimeout(r, 1000));
+        console.log(chalk.gray("  8/8 Running tests..."));
+        const skipArg = opts && opts.skipPassed
+          ? `(setq @::*test-skip-file* "${path.join(os.homedir(), "@lisp", ".atlisp", "test-passed.lst").replace(/\\/g, "/")}")`
+          : "";
+        return await mcp.evalLisp(
+          `(if (not (boundp '@::run-tests)) (load "${_runnerPath}"))
+${skipArg}
+(princ (strcat "\\nRegistered " (itoa (length @::*test-runner-tests*)) " tests\\n"))
+(@::run-tests nil)`);
+      });
+      console.log(chalk.green("  ✓ 测试完成"));
+      if (output) console.log(output);
+      process.exit(0);
+      } catch (e) {
+        console.error(chalk.red(`  ✗ ${e.message}`));
+        if (e.message.includes("Circuit breaker") || e.message.includes("worker")) {
+          console.log(chalk.yellow("\nMCP 连接不稳定。请尝试:\n"));
+          console.log(chalk.cyan("  1. 确保 CAD 已打开且无弹窗阻塞\n"));
+          console.log(chalk.cyan("  2. 重启 atlisp-mcp-server\n"));
+          console.log(chalk.cyan("  3. 用 --manual 模式手动测试:\n"));
+          console.log(chalk.gray(`     node atlisp.js test --platform cad --manual\n`));
+        } else if (e.message.includes("ENOENT") || e.message.includes("spawn")) {
+          console.log(chalk.yellow("\natlisp-mcp 未安装。请执行:\n"));
+          console.log(chalk.cyan("  npm install -g @atlisp/mcp\n"));
+          console.log(chalk.gray("或用 --manual 模式手动在 CAD 中执行测试:\n"));
+          console.log(chalk.gray(`  node atlisp.js test --platform cad --manual\n`));
+        }
+        process.exit(1);
+    }
+  }
+}
+
+async function handler(args) {
+  const opts = common.parseArgs(args);
+  const testFilter = args.find(a => !a.startsWith("--")) || undefined;
+  await cmdTest(testFilter, opts);
+}
+
+function register(reg) {
+  reg("test", handler, ["t"]);
+}
+
+module.exports = { register };

package/commands/watch.js

@@ -0,0 +1,47 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const SRC_DIR = require("../lib/common").getKernelSrc();
+
+function register(reg) {
+  reg('watch', cmdWatch, ['w']);
+}
+
+async function cmdWatch() {
+  const BUILD_CMD = 'node ../atlisp-cli/atlisp.js build';
+
+  const debounce = (fn, delay) => {
+    let timer;
+    return (...args) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => fn(...args), delay);
+    };
+  };
+
+  const rebuild = debounce(() => {
+    const timestamp = new Date().toLocaleTimeString();
+    console.log(`\n[${timestamp}] Change detected. Rebuilding...`);
+    try {
+      execSync(BUILD_CMD, { cwd: process.cwd(), stdio: 'inherit' });
+      console.log(`[${timestamp}] Build complete.`);
+    } catch (e) {
+      console.error(`[${timestamp}] Build failed.`);
+    }
+  }, 300);
+
+  let ready = false;
+  fs.watch(SRC_DIR, { recursive: true }, (event, filename) => {
+    if (!filename || !filename.endsWith('.lsp')) return;
+    if (!ready) { ready = true; return; }
+    console.log(`  File changed: ${filename}`);
+    rebuild();
+  });
+
+  console.log(`Watching ${SRC_DIR} for changes...`);
+  console.log('Press Ctrl+C to stop.');
+
+  return new Promise(() => {});
+}
+
+module.exports = { register };