@atlisp/cli 1.2.0

package/commands/config.js

@@ -0,0 +1,264 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const common = require("../lib/common");
+
+const SENSITIVE_PREFIX = "__enc__:";
+
+function simpleObfuscate(val) {
+  if (!val || val.length < 4) return val;
+  const buf = Buffer.from(val, "utf-8");
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = (~buf[i]) & 0xFF;
+  }
+  return SENSITIVE_PREFIX + buf.toString("base64");
+}
+
+function simpleDeobfuscate(val) {
+  if (!val || typeof val !== "string" || !val.startsWith(SENSITIVE_PREFIX)) return val;
+  try {
+    const raw = val.slice(SENSITIVE_PREFIX.length);
+    const buf = Buffer.from(raw, "base64");
+    for (let i = 0; i < buf.length; i++) {
+      buf[i] = (~buf[i]) & 0xFF;
+    }
+    return buf.toString("utf-8");
+  } catch {
+    return val;
+  }
+}
+
+const SENSITIVE_KEYS = ["usertoken", "user-token", "useremail", "user-email", "userphone", "user-phone", "enterprise-token", "sso-client-id"];
+
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.includes(key.toLowerCase());
+}
+
+function writeConfigKey(key, val) {
+  const cfgPath = path.join(common.ATLISP_DIR, "config.cfg");
+  let text = "";
+  if (fs.existsSync(cfgPath)) {
+    text = fs.readFileSync(cfgPath, "utf-8");
+  }
+  const stored = isSensitiveKey(key) ? simpleObfuscate(val) : val;
+  const escapedVal = stored.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const linePattern = new RegExp(`^\\(@::${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+".*"\\s*\\)\\s*$`, "gm");
+  const newLine = `(@::${key} "${escapedVal}")`;
+  if (linePattern.test(text)) {
+    text = text.replace(linePattern, newLine);
+  } else {
+    text = text.trimEnd() + "\n" + newLine + "\n";
+  }
+  fs.mkdirSync(common.ATLISP_DIR, { recursive: true });
+  fs.writeFileSync(cfgPath, text, "utf-8");
+}
+
+function writeAtlispConfigKey(key, val) {
+  const configPath = path.join(common.ATLISP_DIR, "atlisp.json");
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try { config = JSON.parse(fs.readFileSync(configPath, "utf-8")); } catch (e) {}
+  }
+  config[key] = isSensitiveKey(key) ? simpleObfuscate(val) : val;
+  fs.mkdirSync(common.ATLISP_DIR, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+function getAuthToken() {
+  return common.readConfigCfg()["user-token"] || common.readAtlispConfig()["user-token"] || "";
+}
+
+function getAuthEmail() {
+  return common.readConfigCfg()["user-email"] || common.readAtlispConfig()["user-email"] || "";
+}
+
+function getAllConfig() {
+  return { cfg: common.readConfigCfg(), json: common.readAtlispConfig() };
+}
+
+function saveAuthToBoth(email, token) {
+  fs.mkdirSync(common.ATLISP_DIR, { recursive: true });
+  writeAtlispConfigKey("user-email", email);
+  writeAtlispConfigKey("user-token", token);
+  writeConfigKey("user-email", email);
+  writeConfigKey("user-token", token);
+}
+
+async function cmdConfig(action, key, val) {
+  const configPath = path.join(common.ATLISP_DIR, "atlisp.json");
+  const all = getAllConfig();
+
+  if (action === "list") {
+    console.log(chalk.cyan("\n@lisp 配置\n"));
+    const seen = new Set();
+    const entries = [];
+    for (const [k, v] of Object.entries(all.cfg)) {
+      seen.add(k);
+      entries.push({ file: "config.cfg", key: k, value: v });
+    }
+    for (const [k, v] of Object.entries(all.json)) {
+      if (!seen.has(k)) {
+        entries.push({ file: "atlisp.json", key: k, value: typeof v === "string" ? v : JSON.stringify(v) });
+      }
+    }
+    seen.clear();
+    if (entries.length === 0) {
+      console.log(chalk.gray("  (空)"));
+    } else {
+      for (const e of entries) {
+        const prefix = e.file === "config.cfg" ? chalk.gray("  cfg.") : chalk.gray("  json.");
+        const val = isSensitiveKey(e.key) ? "****" : (typeof e.value === "string" ? e.value : JSON.stringify(e.value));
+        console.log(prefix + chalk.cyan(e.key) + " = " + chalk.gray(val));
+      }
+    }
+    return;
+  }
+
+  if (action === "get") {
+    if (!key) {
+      console.error(chalk.red("用法: atlisp config get <键>"));
+      process.exit(1);
+    }
+    const v = all.cfg[key] !== undefined ? all.cfg[key] : all.json[key];
+    if (v === undefined) {
+      console.log(chalk.yellow("未找到配置项: " + key));
+    } else {
+      console.log(typeof v === "string" ? v : JSON.stringify(v));
+    }
+    return;
+  }
+
+  if (action === "set") {
+    if (!key || val === undefined) {
+      console.error(chalk.red("用法: atlisp config set <键> <值>"));
+      process.exit(1);
+    }
+    fs.mkdirSync(common.ATLISP_DIR, { recursive: true });
+    writeAtlispConfigKey(key, val);
+    writeConfigKey(key, val);
+    console.log(chalk.green("  ✓ " + key + " = " + val));
+    return;
+  }
+  console.error(chalk.red("用法: atlisp config <get|set|list> [...]"));
+  process.exit(1);
+}
+
+async function cmdLogin(email) {
+  let config = common.readAtlispConfig();
+  const cfgDir = common.ATLISP_DIR;
+
+  if (!email) {
+    const inquirer = require("inquirer");
+    const answers = await inquirer.prompt([
+      { name: "email", type: "input", message: "邮箱?", default: config["user-email"] || "" },
+      { name: "passwd", type: "password", message: "密码?" },
+      { name: "server", type: "input", message: "服务器?", default: "https://atlisp.cn" },
+    ]);
+    email = answers.email;
+    const passwd = answers.passwd;
+    const server = answers.server.replace(/\/+$/, "");
+    console.log(chalk.cyan("\n正在登录..."));
+    try {
+      const resp = await fetch(server + "/make-token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: `email=${encodeURIComponent(email)}&passwd=${encodeURIComponent(passwd)}&locale=zh_CN`,
+      });
+      const text = await resp.text();
+      const m = text.match(/:token\s+"([^"]+)"/);
+      if (m) {
+        const token = m[1];
+        saveAuthToBoth(email, token);
+        config["server-url"] = server;
+        writeAtlispConfigKey("server-url", server);
+        console.log(chalk.green("  ✓ 登录成功! token 已保存到 config.cfg 和 atlisp.json"));
+      } else {
+        const msg = text.match(/:msg\s+"([^"]+)"/);
+        console.error(chalk.red("  ✗ 登录失败: " + (msg ? msg[1] : text)));
+      }
+    } catch (e) {
+      console.error(chalk.red("  ✗ 连接失败: " + e.message));
+    }
+    return;
+  }
+  saveAuthToBoth(email, "");
+  console.log(chalk.green("  ✓ email 已设置: " + email));
+  console.log(chalk.gray("  请手动设置 token: atlisp config set user-token <你的token>"));
+}
+
+async function cmdSync(opts) {
+  const token = getAuthToken();
+  const email = getAuthEmail();
+  const json = common.readAtlispConfig();
+  if (!email || !token) {
+    console.error(chalk.red("错误: 未设置 user-email 和 user-token。"));
+    console.error(chalk.gray("请在 CAD 中用 @login 命令登录，"));
+    console.error(chalk.gray("或在 ~/.atlisp/ 中配置。"));
+    process.exit(1);
+  }
+  const baseUrl = json["server-url"] || "https://atlisp.cn";
+  const action = opts.push ? "push" : opts.pull ? "pull" : opts.status ? "status" : "full";
+  console.log(chalk.cyan(`\n配置同步 (${action})`));
+
+  if (action === "status" || action === "full") {
+    try {
+      const url = `${baseUrl}/api/user/sync/status?token=${token}`;
+      const response = await fetch(url);
+      const text = await response.text();
+      console.log("  服务器端状态: " + text);
+    } catch (e) {
+      console.error(chalk.red("  ✗ 连接服务器失败: " + e.message));
+    }
+  }
+  if (action === "push" || action === "full") {
+    try {
+      const cfgPath = path.join(common.ATLISP_DIR, "config.cfg");
+      const localConfig = fs.existsSync(cfgPath) ? fs.readFileSync(cfgPath, "utf-8") : "";
+      console.log("  ✓ 已向服务器发送同步请求");
+      console.log(chalk.gray("  完整同步请在 CAD 中使用 C:@SYNC 命令"));
+    } catch (e) {
+      console.error(chalk.red("  ✗ 同步失败: " + e.message));
+    }
+  }
+  console.log("");
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  if (cmd === "login") {
+    await cmdLogin(args[1]);
+  } else if (cmd === "sync") {
+    const opts = {};
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--push") opts.push = true;
+      else if (args[i] === "--pull") opts.pull = true;
+      else if (args[i] === "--status") opts.status = true;
+    }
+    await cmdSync(opts);
+  } else {
+    await cmdConfig(args[1], args[2], args[3]);
+  }
+}
+
+function register(reg) {
+  reg("config", (args) => cmdConfig(args[0], args[1], args[2]));
+  reg("login", (args) => cmdLogin(args[0]));
+  reg("sync", (args) => {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--push") opts.push = true;
+      else if (args[i] === "--pull") opts.pull = true;
+      else if (args[i] === "--status") opts.status = true;
+    }
+    return cmdSync(opts);
+  });
+}
+
+module.exports = {
+  register, saveAuthToBoth,
+  readConfigCfg: common.readConfigCfg,
+  readAtlispConfig: common.readAtlispConfig,
+  getAuthToken: common.getAuthToken,
+  getAuthEmail: () => common.readConfigCfg()["user-email"] || common.readAtlispConfig()["user-email"] || "",
+  getAllConfig: () => ({ cfg: common.readConfigCfg(), json: common.readAtlispConfig() }),
+};

package/commands/dcl-migrate.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+function register(reg) {
+  reg('dcl-migrate', cmdDclMigrate, ['dclm']);
+}
+
+async function cmdDclMigrate(args) {
+  const filePath = args[0];
+  if (!filePath) {
+    console.error(chalk.red('用法: atlisp dcl-migrate <dcl-文件路径>'));
+    process.exit(1);
+  }
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`文件不存在: ${filePath}`));
+    process.exit(1);
+  }
+
+  const dcl = fs.readFileSync(filePath, 'utf-8');
+  const lines = dcl.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+
+  const indent = '  ';
+  let result = "'(";
+  let depth = 0;
+
+  for (const line of lines) {
+    if (line.startsWith('//') || line.startsWith('/*')) continue;
+
+    const isClose = line.includes('}');
+    const isOpen = line.includes('{');
+
+    const widgetName = line.split(':')[0].trim();
+    if (widgetName && !widgetName.includes('=') && !widgetName.startsWith('}')) {
+      result += `\n${indent.repeat(depth)}:${widgetName}`;
+    }
+
+    const attrs = line.match(/(\w+)\s*=\s*("[^"]*"|[^;{]+);/g);
+    if (attrs) {
+      for (const attr of attrs) {
+        const [key, val] = attr.split('=').map(s => s.trim().replace(/;$/, ''));
+        const formattedVal = val.startsWith('"') ? val : val;
+        result += `\n${indent.repeat(depth + 1)}:${key} ${formattedVal}`;
+      }
+    }
+
+    if (isOpen) depth++;
+    if (isClose) depth--;
+  }
+
+  result += ')';
+
+  const outPath = filePath.replace(/\.dcl$/i, '.lsp.dsl');
+  fs.writeFileSync(outPath, `;; Converted from ${path.basename(filePath)}\n;; DCL DSL format — use with @::dcl-dialog\n${result}\n`, 'utf-8');
+  console.log(chalk.green(`\n✓ Converted DCL to DSL: ${outPath}`));
+  console.log(chalk.gray('\n注意: 转换需要人工审查。请检查:'));
+  console.log(chalk.gray('  - child_order 属性（DCL 中控件顺序已隐含）'));
+  console.log(chalk.gray('  - 回调函数（action_tile 需要手动添加）'));
+  console.log(chalk.gray('  - 确保结果用 dcl:dialog 包裹'));
+}
+
+module.exports = { register };

package/commands/doc.js

@@ -0,0 +1,45 @@
+const http = require("http");
+const chalk = require("chalk");
+
+async function cmdDoc(funcName) {
+  if (!funcName) {
+    console.error(chalk.red("用法: atlisp doc <函数名>\n  示例: atlisp doc string:length"));
+    process.exit(1);
+  }
+  try {
+    console.log(chalk.cyan(`\n正在查询函数 "${funcName}" ...`));
+    const data = await new Promise((resolve, reject) => {
+      http.get(`http://atlisp.org/api/function-desc?fun-name=${encodeURIComponent(funcName)}`,
+        { headers: { "User-Agent": "Atlisp-CLI" } },
+        (res) => { let d = ""; res.on("data", c => d += c); res.on("end", () => resolve(d)); }
+      ).on("error", reject);
+    });
+    if (data && data.startsWith("{")) {
+      const desc = JSON.parse(data);
+      const info = desc[funcName] || desc;
+      console.log("\n" + chalk.white.bold(funcName));
+      console.log(chalk.gray("─".repeat(50)));
+      if (info.usage) console.log(chalk.yellow("  用法:  ") + info.usage);
+      if (info.description) console.log(chalk.yellow("  说明:  ") + (info.description || info.usage));
+      if (info.example || (info.examples && info.examples.length > 0)) {
+        const exs = info.example ? [info.example] : info.examples;
+        console.log(chalk.yellow("  示例:"));
+        exs.forEach(ex => console.log(chalk.gray("    " + ex)));
+      }
+      if (info.returns) console.log(chalk.yellow("  返回:  ") + info.returns);
+      console.log(chalk.gray(`\n  完整文档: http://atlisp.cn/function/${funcName}`));
+    } else {
+      console.log(chalk.yellow(`\n未找到函数 "${funcName}" 的文档。`));
+      console.log(chalk.gray(`  可尝试: atlisp search ${funcName}`));
+    }
+  } catch (err) {
+    console.error(chalk.red(`\n查询失败: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+function register(reg) {
+  reg("doc", (args) => cmdDoc(args[0]));
+}
+
+module.exports = { register };

package/commands/doctor.js

@@ -0,0 +1,292 @@
+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");
+
+const KERNEL_SRC = common.getKernelSrc();
+const MODULES_SRC = path.join(KERNEL_SRC, "modules");
+const KERNEL_ORDER = require("../kernel-order.json");
+
+function findModuleSubfiles(moduleName) {
+  const moduleDir = path.join(MODULES_SRC, moduleName);
+  if (!fs.existsSync(moduleDir)) return [];
+  function collectFiles(dir, prefix) {
+    let result = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries.sort()) {
+      const relPath = prefix ? path.join(prefix, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        result = result.concat(collectFiles(path.join(dir, entry.name), relPath));
+      } else if (entry.isFile() && entry.name.endsWith(".lsp") &&
+                 entry.name.startsWith(moduleName + "-")) {
+        result.push(relPath);
+      }
+    }
+    return result;
+  }
+  return collectFiles(moduleDir, moduleName);
+}
+
+function getAuthToken() {
+  return common.getAuthToken();
+}
+
+function getAuthEmail() {
+  return readConfigCfg().userEmail || readAtlispConfig()["user-email"];
+}
+
+function buildModule(moduleName, outPath) {
+  const subfiles = findModuleSubfiles(moduleName);
+  if (subfiles.length === 0) {
+    console.error(chalk.red(`错误: 在 ${path.join(MODULES_SRC, moduleName)}/ 中未找到子文件`));
+    return;
+  }
+  if (!outPath) {
+    outPath = path.join(MODULES_SRC, moduleName + ".lsp");
+  }
+  console.log(chalk.gray(`    正在构建 ${moduleName}.lsp ...`));
+  const buildCmd = require("./build");
+  buildCmd.buildModule(moduleName, outPath);
+}
+
+async function cmdDoctor(opts) {
+  const fixMode = opts && opts.fix;
+  const jsonMode = opts && opts.json;
+  const atlispDir = common.ATLISP_DIR;
+  let ok = 0, warn = 0, fail = 0, fixed = 0;
+  const jsonResults = [];
+
+  const jsonAdd = (label, status, msg) => {
+    jsonResults.push({ check: label, status, message: msg || "" });
+  };
+  const check = (label, pass, msg) => {
+    jsonAdd(label, pass ? "ok" : "fail", msg);
+    if (jsonMode) return;
+    if (pass) { console.log("  ✓ " + label + (msg ? ": " + msg : "")); ok++; }
+    else { console.log("  ✗ " + label + (msg ? ": " + msg : "")); fail++; }
+  };
+  const checkWarn = (label, msg) => {
+    jsonAdd(label, "warn", msg);
+    if (jsonMode) return;
+    console.log("  ⚠ " + label + ": " + msg); warn++;
+  };
+  const checkFixed = (label, msg) => {
+    jsonAdd(label, "fixed", msg);
+    if (jsonMode) return;
+    console.log("  🔧 " + label + (msg ? ": " + msg : "")); fixed++;
+  };
+
+  if (!jsonMode) {
+    if (fixMode) console.log(chalk.cyan("\n@lisp 环境诊断 + 修复模式\n"));
+    else console.log(chalk.cyan("\n@lisp 环境诊断\n"));
+  }
+
+  const hasAtlispDir = fs.existsSync(atlispDir);
+  check("@lisp 主页", hasAtlispDir, atlispDir);
+  if (fixMode && !hasAtlispDir) {
+    fs.mkdirSync(atlispDir, { recursive: true });
+    checkFixed("已创建 @lisp 主页", atlispDir);
+  }
+
+  const configPath = path.join(atlispDir, "atlisp.json");
+  const cfgPath = path.join(atlispDir, "config.cfg");
+  const hasJson = fs.existsSync(configPath);
+  const hasCfg = fs.existsSync(cfgPath);
+  check("atlisp.json", hasJson, hasJson ? "存在" : "不存在");
+  check("config.cfg", hasCfg, hasCfg ? "存在" : "不存在");
+
+  const token = getAuthToken();
+  const email = getAuthEmail();
+  if (email) {
+    check("user-email", true, email + (hasCfg && readConfigCfg().userEmail ? " (config.cfg)" : " (atlisp.json)"));
+  } else {
+    checkWarn("user-email", "未设置");
+  }
+  if (token) {
+    check("user-token", true, "已设置" + (hasCfg && readConfigCfg().userToken ? " (config.cfg)" : " (atlisp.json)"));
+  } else {
+    checkWarn("user-token", "未设置");
+  }
+
+  const pkgInUse = path.join(atlispDir, "pkg-in-use.lst");
+  if (fs.existsSync(pkgInUse)) {
+    const pkgs = fs.readFileSync(pkgInUse, "utf-8").split("\n").filter(Boolean).length;
+    check("已安装包列表", true, pkgs + " 个包");
+  } else {
+    checkWarn("已安装包列表", "不存在");
+  }
+
+  const lispDir = path.join(os.homedir(), "@lisp");
+  const dirs = [lispDir, path.join(lispDir, "packages"), path.join(lispDir, "locale"),
+    path.join(lispDir, "bin")];
+  for (const d of dirs) {
+    if (fs.existsSync(d)) check("目录 " + path.basename(d), true);
+  }
+
+  const versionFile = path.join(KERNEL_SRC, "version.lsp");
+  if (fs.existsSync(versionFile)) {
+    const verContent = fs.readFileSync(versionFile, "utf-8");
+    const m = verContent.match(/"([^"]+)"/);
+    check("内核版本", !!m, m ? m[1] : "");
+  } else {
+    const builtKernel = path.join(lispDir, "@lisp_u.lsp");
+    if (fs.existsSync(builtKernel)) {
+      const m = fs.readFileSync(builtKernel, "utf-8").match(/version\s+"([^"]+)"/i);
+      check("内核版本", !!m, m ? m[1] : "?");
+    } else {
+      checkWarn("内核版本", "未找到");
+    }
+  }
+
+  let allExist = true;
+  let missingSrc = [];
+  for (const f of KERNEL_ORDER) {
+    const p = path.join(KERNEL_SRC, f);
+    if (!fs.existsSync(p)) { allExist = false; missingSrc.push(f); }
+  }
+  if (allExist) check("内核源文件完整性", true, KERNEL_ORDER.length + " 个文件");
+  else check("内核源文件完整性", false, "缺少: " + missingSrc.join(", "));
+
+  if (fs.existsSync(MODULES_SRC)) {
+    for (const entry of fs.readdirSync(MODULES_SRC, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        const subfiles = findModuleSubfiles(entry.name);
+        const builtFile = path.join(MODULES_SRC, entry.name + ".lsp");
+        if (subfiles.length > 0) {
+          check("模块 " + entry.name, fs.existsSync(builtFile),
+            subfiles.length + " 子文件, " + (fs.existsSync(builtFile) ? "已构建" : "未构建"));
+        }
+      }
+    }
+  }
+
+  try {
+    const start = Date.now();
+    const resp = await fetch(common.API_BASE, {
+      timeout: 5000,
+      headers: { "User-Agent": "Atlisp-User" },
+    });
+    const ms = Date.now() - start;
+    if (resp.status === 403) {
+      check("网络连接", true, common.API_BASE + " 已连接 (" + ms + "ms)");
+    } else {
+      check("网络连接", resp.ok, common.API_BASE + " (" + resp.status + ", " + ms + "ms)");
+    }
+  } catch (e) {
+    checkWarn("网络连接", common.API_BASE + " 不可达 (" + e.message + ")");
+  }
+
+  if (cad.isWindows()) {
+    const cadResult = cad.checkCAD();
+    if (cadResult.ok) check("CAD 连接", true, cadResult.name + " v" + cadResult.version);
+    else checkWarn("CAD 连接", cadResult.error);
+  } else {
+    checkWarn("CAD 连接", "仅 Windows 支持");
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok, warn, fail, fixed, results: jsonResults }, null, 2));
+    return;
+  }
+  console.log(chalk.gray("\n── 诊断结果 ──────────────────────"));
+  console.log(chalk.green("  ✓ " + ok + " 项正常"));
+  if (warn > 0) console.log(chalk.yellow("  ⚠ " + warn + " 项警告"));
+  if (fail > 0) console.log(chalk.red("  ✗ " + fail + " 项错误"));
+  if (fixed > 0) console.log(chalk.green("  🔧 " + fixed + " 项已修复"));
+  console.log("");
+
+  if (fixMode) {
+    let repairCount = 0;
+    const lispDir = path.join(os.homedir(), "@lisp");
+    const requiredDirs = [lispDir, path.join(lispDir, "packages"),
+      path.join(lispDir, "locale"), path.join(lispDir, "bin")];
+    for (const d of requiredDirs) {
+      if (!fs.existsSync(d)) {
+        fs.mkdirSync(d, { recursive: true });
+        console.log(chalk.green("  🔧 创建目录: " + d));
+        repairCount++;
+      }
+    }
+
+    if (!fs.existsSync(pkgInUse)) {
+      fs.writeFileSync(pkgInUse, "", "utf-8");
+      console.log(chalk.green("  🔧 创建空文件: " + pkgInUse));
+      repairCount++;
+    }
+
+    if (!fs.existsSync(configPath)) {
+      fs.writeFileSync(configPath, "{}", "utf-8");
+      console.log(chalk.green("  🔧 创建配置: " + configPath));
+      repairCount++;
+    }
+
+    const moduleSrcDir = MODULES_SRC;
+    if (fs.existsSync(moduleSrcDir)) {
+      for (const entry of fs.readdirSync(moduleSrcDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          const subfiles = findModuleSubfiles(entry.name);
+          const builtFile = path.join(moduleSrcDir, entry.name + ".lsp");
+          if (subfiles.length > 0 && !fs.existsSync(builtFile)) {
+            buildModule(entry.name, builtFile);
+            repairCount++;
+          }
+        }
+      }
+    }
+
+    const builtKernel = path.join(lispDir, "@lisp_u.lsp");
+    if (!fs.existsSync(builtKernel)) {
+      const buildCmd = require("./build");
+      buildCmd.cmdBuild();
+      repairCount++;
+    }
+
+    if (repairCount > 0) {
+      console.log(chalk.green("\n  🔧 修复完成: " + repairCount + " 项"));
+    } else {
+      console.log(chalk.gray("\n  无需修复"));
+    }
+    console.log("");
+  }
+}
+
+async function cmdCheck(opts) {
+  const jsonMode = opts && opts.json;
+  const result = cad.checkCAD();
+  if (jsonMode) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log("\n检查 CAD 连接...");
+    if (result.ok) {
+      console.log("  ✓ " + result.name + " (版本: " + result.version + ")");
+    } else {
+      console.log("  ✗ " + result.error);
+    }
+  }
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  const opts = common.parseArgs(args.slice(1));
+  if (cmd === "check") {
+    await cmdCheck(opts);
+  } else {
+    await cmdDoctor(opts);
+  }
+}
+
+function register(reg) {
+  reg("doctor", (args) => {
+    const opts = {};
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--fix") opts.fix = true;
+      else if (args[i] === "--json") opts.json = true;
+    }
+    return cmdDoctor(opts);
+  });
+  reg("check", (args) => cmdCheck({ json: args.includes("--json") }));
+}
+
+module.exports = { register };

package/commands/find.js

@@ -0,0 +1,14 @@
+const chalk = require("chalk");
+const { find } = require("../lib/find");
+const { parseArgs } = require("../lib/common");
+
+async function cmdFind(opts) {
+  const result = await find(opts);
+  if (!result) process.exit(1);
+}
+
+function register(reg) {
+  reg("find", (args) => cmdFind(parseArgs(args)));
+}
+
+module.exports = { register };