@atlisp/cli 1.2.0

package/atlisp.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+const chalk = require("chalk");
+const figlet = require("figlet");
+const inquirer = require("inquirer");
+const path = require("path");
+const cmdreg = require("./commands/index");
+
+// Load all command modules
+cmdreg.load(path.join(__dirname, "commands"));
+
+const COMMANDS = cmdreg.getAll();
+
+const HELP = `@atlisp/cli v${require("./package.json").version}
+用法:
+  atlisp [命令] [选项]
+
+环境变量:
+  ATLISP_KERNEL_SRC    内核源码目录 (默认 ~/atlisp/kernel/src)
+  ATLISP_KERNEL_TEST   内核测试目录 (默认 ~/atlisp/kernel/test)
+  ATLISP_KERNEL_ROOT   内核根目录   (默认 ~/atlisp/kernel)
+
+命令:
+
+命令:
+  install [--auto]          显示 @lisp Core 安装代码（--auto 自动安装到 CAD）
+  pull <包名> [--auto] [--download]  拉取/下载应用包
+  remove <包名> [--auto]    卸载应用包
+  list                      列出所有可用应用包
+  search <关键词>           搜索应用包
+  init <包名> [--template basic|dialog|ai|enterprise]  创建包项目脚手架
+  checksum <文件>           计算并添加 @checksum: 到模块文件
+  config get <键>            读取 @lisp 配置项
+  config set <键> <值>       设置 @lisp 配置项
+  config list                列出所有 @lisp 配置项
+  login [<邮箱>]             登录 @lisp 账号并保存 token
+  build [--out <路径>]      构建 @lisp_u.lsp 单体文件
+  build-module <模块名> [--out <路径>]  构建模块单体文件
+  deploy                     部署 src/modules/*.lsp 到 dev.atlisp.cn
+   test [--platform sbcl|cad] [--list] [--load] [--manual] [--skip-passed]  运行测试
+  batch --path <路径> --expr <表达式>  批处理 DWG 文件
+  find --path <路径> --name <名称>  在 DWG 中查找元素
+  check                     检查 CAD 连接状态
+  doctor [--fix]            环境诊断（--fix 自动修复）
+  qrcode <文本>             生成终端二维码
+  qrcode-ascii <文本>       生成终端二维码（ASCII 模式）
+  info <包名>               查看已安装包的详细信息
+  doc <函数名>              查询函数文档
+  sync [--push|--pull|--status]  触发配置同步
+  --version, -V             显示版本
+  --help, -h                显示帮助
+
+不带参数时启动交互式菜单。`;
+
+function showBanner() {
+  console.log(
+    chalk.green(
+      figlet.textSync("@Lisp", {
+        font: "Ghost",
+        horizontalLayout: "default",
+        verticalLayout: "default",
+      })
+    )
+  );
+  console.log("@lisp — CAD 应用云管理器。支持 AutoCAD、中望CAD、浩辰CAD、BricsCAD。");
+}
+
+async function runCLI(args) {
+  const cmd = args[0];
+  const rest = args.slice(1);
+
+  if (cmd === "--version" || cmd === "-V") {
+    console.log(require("./package.json").version);
+    return;
+  }
+  if (cmd === "--help" || cmd === "-h" || cmd === undefined) {
+    console.log(HELP);
+    return;
+  }
+
+  const handler = cmdreg.get(cmd);
+  if (handler) {
+    await handler(rest);
+  } else {
+    console.error(chalk.red("未知命令: " + cmd + "\n"));
+    console.log(HELP);
+    process.exit(1);
+  }
+}
+
+async function runInteractive() {
+  showBanner();
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "COMMAND",
+      message: "请选择你要执行的任务?",
+      choices: [
+        "install core", "install core (auto)",
+        "pull package", "pull package (auto)", "download package (local)",
+        "remove package", "remove package (auto)",
+        "list packages", "search package",
+        new inquirer.Separator(),
+        "init new package project",
+        "query function doc",
+        "login @lisp account",
+        "build @lisp_u.lsp", "build network module", "build pkgman module",
+        new inquirer.Separator(),
+        "test (SBCL)", "test (CAD/MCP)", "check CAD", "doctor", "sync config",
+        "generate QR code", "generate QR code (ascii)",
+        new inquirer.Separator(),
+        "batch process DWGs", "find in DWGs",
+      ],
+    },
+  ]);
+  const { COMMAND } = answers;
+  if (COMMAND === "install core") {
+    await cmdreg.get("install")([]);
+  } else if (COMMAND === "install core (auto)") {
+    await cmdreg.get("install")(["--auto"]);
+  } else if (COMMAND === "pull package") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入包名?" },
+    ]);
+    await cmdreg.get("pull")([PKGNAME]);
+  } else if (COMMAND === "pull package (auto)") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入包名?" },
+    ]);
+    await cmdreg.get("pull")([PKGNAME, "--auto"]);
+  } else if (COMMAND === "download package (local)") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入包名?" },
+    ]);
+    await cmdreg.get("pull")([PKGNAME, "--download"]);
+  } else if (COMMAND === "remove package") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入要卸载的包名?" },
+    ]);
+    await cmdreg.get("remove")([PKGNAME]);
+  } else if (COMMAND === "remove package (auto)") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入要卸载的包名?" },
+    ]);
+    await cmdreg.get("remove")([PKGNAME, "--auto"]);
+  } else if (COMMAND === "list packages") {
+    await cmdreg.get("list")([]);
+  } else if (COMMAND === "search package") {
+    const { QUERY } = await inquirer.prompt([
+      { name: "QUERY", type: "input", message: "请输入搜索关键词?" },
+    ]);
+    await cmdreg.get("search")([QUERY]);
+  } else if (COMMAND === "init new package project") {
+    const { PKGNAME } = await inquirer.prompt([
+      { name: "PKGNAME", type: "input", message: "请输入包名?" },
+    ]);
+    const { TEMPLATE } = await inquirer.prompt([
+      { name: "TEMPLATE", type: "list", message: "选择模板?",
+        choices: ["basic (minimal)", "dialog (with DCL)", "ai (with AI agent)", "enterprise (with RBAC)"] },
+    ]);
+    const tplMap = { "basic (minimal)": "basic", "dialog (with DCL)": "dialog", "ai (with AI agent)": "ai", "enterprise (with RBAC)": "enterprise" };
+    process.argv.push("--template", tplMap[TEMPLATE]);
+    await cmdreg.get("init")([PKGNAME]);
+  } else if (COMMAND === "query function doc") {
+    const { FUNCNAME } = await inquirer.prompt([
+      { name: "FUNCNAME", type: "input", message: "请输入函数名 (如 string:length)?" },
+    ]);
+    await cmdreg.get("doc")([FUNCNAME]);
+  } else if (COMMAND === "login @lisp account") {
+    await cmdreg.get("login")([]);
+  } else if (COMMAND === "build @lisp_u.lsp") {
+    await cmdreg.get("build")([]);
+  } else if (COMMAND === "build network module") {
+    await cmdreg.get("build-module")(["network"]);
+  } else if (COMMAND === "build pkgman module") {
+    await cmdreg.get("build-module")(["pkgman"]);
+  } else if (COMMAND === "test (SBCL)") {
+    await cmdreg.get("test")(["--platform", "sbcl"]);
+  } else if (COMMAND === "test (CAD/MCP)") {
+    await cmdreg.get("test")(["--platform", "cad"]);
+  } else if (COMMAND === "check CAD") {
+    await cmdreg.get("check")([]);
+  } else if (COMMAND === "doctor") {
+    await cmdreg.get("doctor")([]);
+  } else if (COMMAND === "sync config") {
+    await cmdreg.get("sync")(["--status"]);
+  } else if (COMMAND === "generate QR code") {
+    const { TEXT } = await inquirer.prompt([
+      { name: "TEXT", type: "input", message: "输入二维码内容?" },
+    ]);
+    await cmdreg.get("qrcode")([TEXT]);
+  } else if (COMMAND === "generate QR code (ascii)") {
+    const { TEXT } = await inquirer.prompt([
+      { name: "TEXT", type: "input", message: "输入二维码内容?" },
+    ]);
+    await cmdreg.get("qrcode-ascii")([TEXT]);
+  } else if (COMMAND === "batch process DWGs") {
+    const answers = await inquirer.prompt([
+      { name: "path", type: "input", message: "DWG 目录路径?" },
+      { name: "expr", type: "input", message: "Lisp 表达式?" },
+      { name: "save", type: "confirm", message: "保存修改?", default: false },
+    ]);
+    await cmdreg.get("batch")(["--path", answers.path, "--expr", answers.expr, "--save", String(answers.save), "--force"]);
+  } else if (COMMAND === "find in DWGs") {
+    const answers = await inquirer.prompt([
+      { name: "path", type: "input", message: "DWG 目录路径?" },
+      { name: "name", type: "input", message: "要查找的元素名称?" },
+      { name: "table", type: "input", message: "表名 (默认 Blocks)?", default: "Blocks" },
+    ]);
+    await cmdreg.get("find")(["--path", answers.path, "--name", answers.name, "--table", answers.table]);
+  }
+}
+
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  runInteractive().catch(err => console.error(chalk.red(err.message)));
+} else {
+  runCLI(args).catch(err => console.error(chalk.red(err.message)));
+}

package/commands/batch.js

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

package/commands/build.js

@@ -0,0 +1,267 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const { parseArgs, getKernelSrc } = require("../lib/common");
+const { topologicalSort, KERNEL_ORDER: ORDER } = require("../lib/deps");
+const KERNEL_SRC = getKernelSrc();
+const KERNEL_ROOT = path.dirname(KERNEL_SRC);
+
+const MODULES_SRC = path.join(KERNEL_ROOT, "modules");
+const KERNEL_ORDER = (() => {
+  try {
+    const cached = require("../kernel-order.json");
+    return cached;
+  } catch (e) {
+    // 无缓存文件时从注解推导
+    try {
+      return topologicalSort();
+    } catch (e2) {
+      console.error(chalk.yellow("  ⚠ kernel-order.json 不存在且无法从注解推导，扫描 src/ 目录"));
+      return [];
+    }
+  }
+})();
+
+const DEPS_RE = /;;\s*@depends\s+(.+)/;
+const PROVIDES_RE = /;;\s*@provides\s+(.+)/;
+
+function readAnnotations(filePath) {
+  if (!fs.existsSync(filePath)) return { deps: [], provides: [] };
+  const content = fs.readFileSync(filePath, "utf-8");
+  const firstLines = content.split("\n").slice(0, 10);
+  const depsLine = firstLines.find(l => DEPS_RE.test(l));
+  const provLine = firstLines.find(l => PROVIDES_RE.test(l));
+  const deps = depsLine ? depsLine.match(DEPS_RE)[1].trim().split(/\s+/) : [];
+  const provides = provLine ? provLine.match(PROVIDES_RE)[1].trim().split(/\s+/) : [];
+  return { deps, provides };
+}
+
+function validateDeps() {
+  const fileProvides = {};
+  const fileDeps = {};
+  const order = KERNEL_ORDER.length > 0 ? KERNEL_ORDER : (() => {
+    try {
+      const deps = require("../lib/deps");
+      const allFiles = [];
+      function walk(dir) {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          const p = path.join(dir, e.name);
+          if (e.isDirectory() && !e.name.startsWith(".")) walk(p);
+          else if (e.isFile() && e.name.endsWith(".lsp")) allFiles.push(path.relative(KERNEL_SRC, p));
+        }
+      }
+      walk(KERNEL_SRC);
+      return deps.topologicalSort(allFiles);
+    } catch (e) { return []; }
+  })();
+
+  for (const f of order) {
+    const fullPath = path.join(KERNEL_SRC, f);
+    const anno = readAnnotations(fullPath);
+    fileProvides[f] = anno.provides;
+    fileDeps[f] = anno.deps;
+    for (const p of anno.provides) {
+      if (fileProvides[p] && fileProvides[p] !== f) {
+        console.warn(chalk.yellow(`  ⚠ Duplicate provides "${p}" in ${f} and ${fileProvides[p]}`));
+      }
+    }
+  }
+
+  let issues = [];
+  for (const f of KERNEL_ORDER) {
+    const allProvided = new Set();
+    for (const prev of KERNEL_ORDER) {
+      if (prev === f) break;
+      for (const p of (fileProvides[prev] || [])) allProvided.add(p);
+    }
+    for (const dep of (fileDeps[f] || [])) {
+      if (!allProvided.has(dep)) {
+        issues.push(`${f}: missing dependency "${dep}" (not provided by any preceding file)`);
+      }
+    }
+  }
+
+  if (issues.length > 0) {
+    console.error(chalk.red("\n  ✗ Dependency validation failed:\n"));
+    for (const issue of issues) {
+      console.error(chalk.red("    " + issue));
+    }
+    console.log("");
+    return false;
+  }
+  return true;
+}
+
+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 concatFiles(files, srcDir, baseDir) {
+  const parts = [];
+  for (const f of files) {
+    const fullPath = path.join(srcDir, f);
+    if (!fs.existsSync(fullPath)) {
+      console.error(chalk.red(`错误: 找不到文件 ${fullPath}`));
+      process.exit(1);
+    }
+    const content = fs.readFileSync(fullPath, "utf-8").replace(/[ \t]+$/gm, "");
+    const header = baseDir
+      ? `;; ── ${path.relative(baseDir, fullPath)} ──────────────────────────────────────────\n`
+      : `;; ── ${f} ──────────────────────────────────────────\n`;
+    parts.push(header + content);
+  }
+  return parts.join("\n\n");
+}
+
+function buildModule(moduleName, outPath) {
+  const subfiles = findModuleSubfiles(moduleName);
+  if (subfiles.length === 0) {
+    console.error(chalk.red(`错误: 在 ${path.join(MODULES_SRC, moduleName)}/ 中未找到子文件`));
+    process.exit(1);
+  }
+  if (!outPath) {
+    outPath = path.join(MODULES_SRC, moduleName + ".lsp");
+  }
+  console.log(chalk.cyan(`正在构建 modules/${moduleName}.lsp...`));
+  const concatenated = concatFiles(subfiles, MODULES_SRC, MODULES_SRC);
+  const fileList = subfiles.map(f => `;; ║         ${f}`).join("\n");
+  const header = `;; ╔══════════════════════════════════════════════════════════╗
+;; ║ ${moduleName}.lsp - @lisp module (monolithic build)${" ".repeat(Math.max(0, 43 - moduleName.length))}║
+;; ║                                                         ║
+;; ║ Auto-generated from ${moduleName}/*.lsp sub-files.${" ".repeat(Math.max(0, 38 - moduleName.length))}║
+${fileList}
+;; ╚══════════════════════════════════════════════════════════╝
+
+`;
+  const output = header + concatenated + "\n";
+  fs.writeFileSync(outPath, output, "utf-8");
+  console.log(chalk.green(`✓ ${subfiles.length} 个子文件已合并 → ${outPath}`));
+}
+
+async function cmdBuild(outPath, opts = {}) {
+  const srcDir = KERNEL_SRC || getKernelSrc();
+  if (!outPath) {
+    outPath = path.join(os.homedir(), "@lisp", "@lisp_u.lsp");
+  }
+
+  if (opts.lint) {
+    console.log(chalk.cyan("运行 lint 检查..."));
+    try {
+      const { cmdLint, collectLspFiles } = require("./lint");
+      await cmdLint(srcDir, false);
+      console.log(chalk.green("  ✓ lint 通过\n"));
+    } catch (e) {
+      if (process.env.CI) process.exit(1);
+    }
+  }
+
+  console.log(chalk.cyan("验证源文件依赖..."));
+  const depsOk = validateDeps();
+  if (!depsOk) {
+    if (process.env.CI) {
+      process.exit(1);
+    }
+    console.log(chalk.yellow("  继续构建（设置 CI=1 可在依赖错误时终止）\n"));
+  } else {
+    console.log(chalk.green("  ✓ 依赖验证通过\n"));
+  }
+
+  console.log(chalk.cyan("正在构建 @lisp_u.lsp..."));
+  const output = concatFiles(KERNEL_ORDER, srcDir);
+  const outDir = path.dirname(outPath);
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  fs.writeFileSync(outPath, output, "utf-8");
+  console.log(chalk.green(`✓ ${KERNEL_ORDER.length} 个文件已合并 → ${outPath}`));
+  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);
+        if (subfiles.length > 0) {
+          buildModule(entry.name, path.join(moduleSrcDir, entry.name + ".lsp"));
+        }
+      }
+    }
+  }
+}
+
+async function cmdBuildModule(moduleName, outPath) {
+  if (!moduleName) {
+    console.log(chalk.cyan("\n可用的模块:"));
+    const entries = fs.readdirSync(MODULES_SRC, { withFileTypes: true });
+    let found = false;
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subfiles = findModuleSubfiles(entry.name);
+        if (subfiles.length > 0) {
+          console.log(chalk.gray("  " + entry.name + " (" + subfiles.length + " 个子文件)"));
+          found = true;
+        }
+      }
+    }
+    if (!found) console.log(chalk.gray("  (没有可通过 build-module 构建的模块)"));
+    console.log(chalk.cyan("\n用法: atlisp build-module <模块名> [--out <路径>]"));
+    console.log(chalk.gray("示例: atlisp build-module network"));
+    return;
+  }
+  return buildModule(moduleName, outPath);
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  const val = args[1];
+  const opts = {};
+  for (let i = 0; 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;
+    }
+  }
+  if (cmd === "build-module" || cmd === "bm") {
+    await cmdBuildModule(val, opts.out);
+  } else if (cmd === "build-network" || cmd === "bn") {
+    console.log(chalk.yellow("⚠ build-network 已弃用，请使用 build-module network"));
+    await cmdBuildModule("network", typeof val === "string" ? val : undefined);
+  } else {
+    await cmdBuild(val, opts);
+  }
+}
+
+function register(reg) {
+  reg("build", (args) => {
+    const opts = parseArgs(args);
+    cmdBuild(opts.out, opts);
+  }, ["b"]);
+  reg("build-module", (args) => {
+    const opts = parseArgs(args);
+    cmdBuildModule(args[0], opts.out);
+  }, ["bm"]);
+  reg("build-network", (args) => {
+    console.log(chalk.yellow("⚠ 已弃用，请使用 build-module network"));
+    const opts = parseArgs(args);
+    cmdBuildModule("network", opts.out);
+  }, ["bn"]);
+}
+
+module.exports = { register, buildModule, findModuleSubfiles, concatFiles, cmdBuild, KERNEL_SRC, MODULES_SRC, KERNEL_ORDER };

package/commands/checksum.js

@@ -0,0 +1,23 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const common = require("../lib/common");
+
+async function handler(args) {
+  const filePath = args[0];
+  if (!filePath) {
+    console.error(chalk.red("用法: atlisp checksum <文件路径>"));
+    process.exit(1);
+  }
+  const content = fs.readFileSync(filePath, "utf-8");
+  const cleanEnd = content.replace(/\n;; @checksum: -?\d+\s*$/, "");
+  const hash = common.computeChecksum(cleanEnd);
+  fs.writeFileSync(filePath, cleanEnd + "\n;; @checksum: " + hash + "\n");
+  console.log(chalk.green("Checksum: " + hash + " → " + filePath));
+}
+
+function register(reg) {
+  reg("checksum", handler, ["cs"]);
+}
+
+module.exports = { register };