@atlisp/cli 1.2.0

package/commands/index.js

@@ -0,0 +1,33 @@
+const fs = require("fs");
+const path = require("path");
+
+const commands = new Map();
+
+function register(name, handler, aliases = []) {
+  commands.set(name, handler);
+  for (const alias of aliases) {
+    commands.set(alias, handler);
+  }
+}
+
+function get(name) {
+  return commands.get(name);
+}
+
+function getAll() {
+  return [...commands.keys()];
+}
+
+function load(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".js") && entry.name !== "index.js") {
+      const mod = require(path.join(dir, entry.name));
+      if (mod.register) {
+        mod.register(register);
+      }
+    }
+  }
+}
+
+module.exports = { register, get, getAll, load };

package/commands/info.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const chalk = require("chalk");
+const common = require("../lib/common");
+
+async function cmdInfo(pkgName) {
+  if (!pkgName) {
+    console.error(chalk.red("请指定包名: atlisp info <包名>"));
+    process.exit(1);
+  }
+  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) {}
+  }
+  const installDir = config.installDir || path.join(os.homedir(), "@lisp");
+  const pkgDir = path.join(installDir, "packages", pkgName);
+  if (fs.existsSync(path.join(pkgDir, "pkg.lsp"))) {
+    const content = fs.readFileSync(path.join(pkgDir, "pkg.lsp"), "utf-8");
+    console.log(chalk.cyan("\n" + pkgName));
+    console.log(chalk.gray("─".repeat(40)));
+    const extract = (key) => {
+      const re = new RegExp(`:${key}\\s+([^)]+)`, "i");
+      const m = content.match(re);
+      return m ? m[1].trim().replace(/"/g, "") : "—";
+    };
+    console.log("  描述:   " + extract("desc"));
+    console.log("  版本:   " + extract("version"));
+    console.log("  作者:   " + extract("author"));
+    console.log("  分类:   " + extract("category"));
+    console.log("  包路径: " + pkgDir);
+    const files = fs.readdirSync(pkgDir);
+    const lspFiles = files.filter(f => f.endsWith(".lsp"));
+    if (lspFiles.length > 0) console.log("  文件:   " + lspFiles.join(", "));
+  } else {
+    console.log(chalk.yellow(`\n包 "${pkgName}" 未安装`));
+    console.log(chalk.gray(`  可用: atlisp pull ${pkgName}`));
+  }
+}
+
+function register(reg) {
+  reg("info", (args) => cmdInfo(args[0]));
+}
+
+module.exports = { register };

package/commands/init.js

@@ -0,0 +1,202 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+async function cmdInit(pkgName) {
+  if (!pkgName) {
+    console.error(chalk.red("用法: atlisp init <包名> [--template basic|dialog|ai|enterprise|module] [--author <作者>]"));
+    process.exit(1);
+  }
+  const opts = {};
+  for (let i = 0; i < process.argv.length; i++) {
+    if (process.argv[i] === pkgName) {
+      const remainingArgs = process.argv.slice(i + 1);
+      for (let j = 0; j < remainingArgs.length; j++) {
+        if (remainingArgs[j].startsWith("--")) {
+          const key = remainingArgs[j].slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+          const val = remainingArgs[j + 1] && !remainingArgs[j + 1].startsWith("--") ? remainingArgs[j + 1] : true;
+          if (val !== true) j++;
+          opts[key] = val;
+        }
+      }
+      break;
+    }
+  }
+  const template = opts.template || "basic";
+  const author = opts.author || process.env.USERNAME || "anonymous";
+  const safe = pkgName.toLowerCase().replace(/[^a-z0-9-]/g, "");
+  if (safe !== pkgName) {
+    console.log(chalk.yellow(`  包名已规范化为: ${safe}`));
+  }
+  const dir = path.join(process.cwd(), safe);
+  if (fs.existsSync(dir)) {
+    console.error(chalk.red(`错误: 目录已存在: ${dir}`));
+    process.exit(1);
+  }
+  fs.mkdirSync(dir, { recursive: true });
+
+  const templates = {
+    basic: {
+      lsp: `;; ${safe}.lsp — @lisp package
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:hello ()
+  "Say hello from ${safe}"
+  "string"
+  "(${safe}:hello)"
+  (strcat (_"Hello, this is ") (_"${safe}") "!"))
+`,
+      extra: []
+    },
+    dialog: {
+      lsp: `;; ${safe}.lsp — @lisp package with DCL dialog
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:dialog (/ dcl-id)
+  "Open main dialog for ${safe}"
+  "string"
+  "(${safe}:dialog)"
+  (require 'dcl:*)
+  (dcl:dialog "${safe}"
+    :button{key="ok";label=(_"OK");is_default=true;}
+    :text{key="msg";label=(_"Welcome to ${safe}!");}))
+`,
+      extra: []
+    },
+    ai: {
+      lsp: `;; ${safe}.lsp — @lisp package with AI agent
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:ask (prompt)
+  "Ask AI about ${safe} related topics"
+  "string"
+  "(${safe}:ask \"How to use?\")"
+  (if (@::load-module 'aibot)
+    (@::chat-prompt prompt (_"${safe}") nil)
+    (_"AI module not available.")))
+`,
+      extra: []
+    },
+    module: {
+      lsp: `;; ${safe}.lsp — @lisp kernel module (on-demand)
+;; Provides: ${safe}
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:hello ()
+  "Example function for ${safe} module"
+  "string"
+  "(${safe}:hello)"
+  (strcat (_"Hello from ${safe} module!")))
+`,
+      extra: [],
+      test: `;; test-${safe}.lsp — tests for ${safe} module
+
+(in-package :@)
+(use-package :autolisp)
+
+(@::deftest '${safe}-loaded
+  '(progn
+     (@::assert-true (boundp '${safe}:hello)
+                     "${safe}:hello is bound")))
+
+(princ (strcat "\\n;; test-${safe}.lsp loaded.\\n"))
+`,
+      subfile: `;; ${safe}/core.lsp — sub-module for ${safe}
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:core-init ()
+  "Initialize core sub-module"
+  "t"
+  "(${safe}:core-init)"
+  t)
+`
+    },
+    enterprise: {
+      lsp: `;; ${safe}.lsp — @lisp enterprise package
+
+(in-package :@)
+(use-package :autolisp)
+
+(defun ${safe}:init ()
+  "Initialize enterprise module"
+  "string"
+  "(${safe}:init)"
+  (@::@log "INFO" (strcat (_"Loading ") "${safe}" (_" enterprise module...)"))
+  (@::define-config (quote ${safe}:enabled) 1 (_"Enable ${safe}"))
+  (@::define-config (quote ${safe}:endpoint) "" (_"Enterprise API endpoint"))
+  (@::@log "INFO" (strcat "${safe}" (_" loaded."))))
+
+(defun ${safe}:check-license ()
+  "Check enterprise license"
+  "bool"
+  "(${safe}:check-license)"
+  (if (= 1 (@::get-config (quote ${safe}:enabled)))
+    (progn
+      (@::require (quote permission:*))
+      (permission:check (quote admin) "${safe}"))
+    nil))
+`,
+      extra: []
+    }
+  };
+
+  const tpl = templates[template] || templates.basic;
+  const pkgLsp = tpl.lsp;
+  const pkgDef = `;; pkg.lsp — ${safe} package definition
+
+(:name "${safe}"
+  :full-name "${safe}"
+  :description "A @lisp package"
+  :version "0.1.0"
+  :author "${author}"
+  :email ""
+  :category "tools"
+  :files ("${safe}")
+  :required nil)
+`;
+
+  fs.writeFileSync(path.join(dir, "pkg.lsp"), pkgDef, "utf-8");
+  fs.writeFileSync(path.join(dir, safe + ".lsp"), pkgLsp, "utf-8");
+  if (template === "dialog") {
+    fs.writeFileSync(path.join(dir, safe + ".dcl"),
+      `${safe} : dialog {\n  label = "${safe}";\n}\n`, "utf-8");
+  }
+  if (template === "module") {
+    const testDir = path.join(process.cwd(), "test");
+    if (!fs.existsSync(testDir)) fs.mkdirSync(testDir, { recursive: true });
+    fs.writeFileSync(path.join(testDir, `test-${safe}.lsp`), tpl.test, "utf-8");
+    const subDir = path.join(dir, safe);
+    fs.mkdirSync(subDir, { recursive: true });
+    fs.writeFileSync(path.join(subDir, "core.lsp"), tpl.subfile, "utf-8");
+  }
+  console.log(chalk.green(`\n✓ 包 "${safe}" 已创建 (模板: ${template}): ${dir}`));
+  console.log(chalk.gray(`  ${dir}/pkg.lsp`));
+  console.log(chalk.gray(`  ${dir}/${safe}.lsp`));
+  if (fs.existsSync(path.join(dir, safe + ".dcl")))
+    console.log(chalk.gray(`  ${dir}/${safe}.dcl`));
+  if (template === "module") {
+    console.log(chalk.gray(`  ${dir}/${safe}/core.lsp`));
+    console.log(chalk.gray(`  test/test-${safe}.lsp`));
+  }
+  console.log(chalk.cyan("\n后续步骤:"));
+  console.log(chalk.gray("  1. 编辑 pkg.lsp 修改描述、版本等信息"));
+  console.log(chalk.gray("  2. 编辑 " + safe + ".lsp 添加功能"));
+  console.log(chalk.gray("  3. 本地测试: atlisp pull " + safe));
+  console.log(chalk.gray("  4. 发布: 上传到 atlisp.cn 或私有仓库"));
+}
+
+function register(reg) {
+  reg("init", (args) => cmdInit(args[0]));
+}
+
+module.exports = { register };

package/commands/install.js

@@ -0,0 +1,23 @@
+const chalk = require("chalk");
+const common = require("../lib/common");
+const cad = require("../lib/cad");
+
+async function handler(args) {
+  const opts = common.parseArgs(args);
+  if (!opts.auto) {
+    console.log("\n安装 @lisp Core 到 CAD...");
+    console.log("复制以下代码到CAD命令行，即可开始安装:\n");
+    console.log(common.installCode);
+    console.log("\n或使用 --auto 参数自动安装（仅 Windows）:");
+    console.log("  atlisp install --auto");
+    return;
+  }
+  console.log("\n自动安装 @lisp Core 到 CAD...");
+  await cad.installAtLisp(opts.app, opts.profile);
+}
+
+function register(reg) {
+  reg("install", handler, ["i"]);
+}
+
+module.exports = { register };

package/commands/lint.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+const { getKernelSrc, getKernelTest, getKernelRoot } = require("../lib/common");
+const KERNEL_ROOT = getKernelRoot();
+const KERNEL_SRC = getKernelSrc();
+const TEST_DIR = getKernelTest();
+const MODULES_DIR = path.join(KERNEL_ROOT, "modules");
+
+async function cmdLint(target, fix) {
+  let lintFiles, applyFixes, loadConfig, formatDefault;
+  try {
+    const runner = require("@atlisp/lint/dist/runner");
+    const configMod = require("@atlisp/lint/dist/config");
+    const formatters = require("@atlisp/lint/dist/formatters");
+    lintFiles = runner.lintFiles;
+    applyFixes = runner.applyFixes;
+    loadConfig = configMod.loadConfig;
+    formatDefault = formatters.formatDefault;
+  } catch (e) {
+    console.error(chalk.red("  ✗ @atlisp/lint 未安装。请运行: npm install @atlisp/lint --save"));
+    process.exit(1);
+  }
+
+  const dirs = target ? [path.resolve(KERNEL_ROOT, target)] : [KERNEL_SRC, TEST_DIR, MODULES_DIR].filter(d => fs.existsSync(d));
+  const config = loadConfig();
+  let hasErrors = false;
+
+  for (const dir of dirs) {
+    const rel = path.relative(KERNEL_ROOT, dir);
+    const files = collectLspFiles(dir);
+    if (files.length === 0) {
+      console.log(chalk.yellow(`  ⚠ ${rel} 中没有 .lsp 文件`));
+      continue;
+    }
+    console.log(chalk.cyan(`\n检查 ${rel} (${files.length} 个文件)...`));
+    const issues = lintFiles(files, config, KERNEL_ROOT);
+    if (issues.length === 0) {
+      console.log(chalk.green("  ✓ 无问题"));
+    } else {
+      const output = formatDefault(issues, null);
+      process.stdout.write(output);
+      if (issues.some(i => i.severity === "error")) hasErrors = true;
+      if (fix) {
+        applyFixes(KERNEL_ROOT, issues, config);
+        console.log(chalk.green(`  ✓ 已修复 ${issues.length} 个问题`));
+      }
+    }
+  }
+  if (hasErrors && !fix) process.exit(1);
+}
+
+function collectLspFiles(dir) {
+  const result = [];
+  function walk(d) {
+    const entries = fs.readdirSync(d, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path.join(d, e.name);
+      if (e.isDirectory()) walk(full);
+      else if (e.name.endsWith(".lsp")) result.push(full);
+    }
+  }
+  walk(dir);
+  return result;
+}
+
+async function handler(args) {
+  const clean = args.filter(a => a !== "--" && a !== "--fix");
+  const fix = args.includes("--fix");
+  const target = clean[0];
+  await cmdLint(target, fix);
+}
+
+function register(reg) {
+  reg("lint", (args) => handler(args), ["check"]);
+}
+
+module.exports = { register, cmdLint, collectLspFiles };

package/commands/list.js

@@ -0,0 +1,99 @@
+const chalk = require("chalk");
+const common = require("../lib/common");
+
+async function cmdList() {
+  console.log("\n正在获取应用包列表...\n");
+  try {
+    const text = await common.httpGet("/packages-list?edition=stable");
+    if (text && text.length > 0) {
+      const pkgs = common.parsePackages(text);
+      if (pkgs.length > 0) {
+        const byCategory = {};
+        for (const p of pkgs) {
+          const cat = p.category || "未分类";
+          if (!byCategory[cat]) byCategory[cat] = [];
+          byCategory[cat].push(p);
+        }
+        for (const [cat, list] of Object.entries(byCategory)) {
+          console.log(chalk.bold("\n【" + cat + "】"));
+          for (const p of list) {
+            console.log("  " + chalk.cyan(p.name) + " - " + p.fullName);
+            if (p.description) console.log("    " + p.description);
+          }
+        }
+        console.log(chalk.gray("\n共 " + pkgs.length + " 个应用包"));
+        return;
+      }
+    }
+  } catch (err) {}
+  const local = common.readLocalPackages();
+  if (local.length > 0) {
+    console.log(chalk.bold("【已安装的本地应用包】"));
+    for (const p of local) {
+      const ver = p.version ? chalk.gray(" v" + p.version) : "";
+      console.log("  " + chalk.cyan(p.name) + ver + " - " + p.fullName);
+      if (p.description) console.log("    " + p.description);
+    }
+    console.log(chalk.gray("\n共 " + local.length + " 个已安装的应用包"));
+    return;
+  }
+  console.log("当前无可用的应用包列表。");
+  console.log("请检查网络连接，或访问 https://atlisp.cn 查看可用应用包。");
+}
+
+async function cmdSearch(query) {
+  if (!query) {
+    console.error(chalk.red("错误: 请指定搜索关键词。用法: atlisp search <关键词>"));
+    process.exit(1);
+  }
+  console.log("\n正在搜索 \"" + query + "\"...\n");
+  const q = query.toLowerCase();
+  let matched = [];
+  try {
+    const text = await common.httpGet("/packages-list?edition=stable");
+    if (text && text.length > 0) {
+      const pkgs = common.parsePackages(text);
+      matched = pkgs.filter(p =>
+        p.name.toLowerCase().includes(q) ||
+        p.fullName.toLowerCase().includes(q) ||
+        p.description.toLowerCase().includes(q) ||
+        p.category.toLowerCase().includes(q)
+      );
+    }
+  } catch (err) {}
+  if (matched.length === 0) {
+    const local = common.readLocalPackages();
+    matched = local.filter(p =>
+      p.name.toLowerCase().includes(q) ||
+      p.fullName.toLowerCase().includes(q) ||
+      p.description.toLowerCase().includes(q)
+    );
+  }
+  if (matched.length === 0) {
+    console.log("未找到与 \"" + query + "\" 相关的应用包。");
+    console.log("请访问 https://atlisp.cn 搜索可用应用包。");
+    return;
+  }
+  for (const p of matched) {
+    console.log("  " + chalk.cyan(p.name) + " - " + p.fullName);
+    if (p.description) console.log("    " + p.description);
+    console.log(chalk.gray("    分类: " + (p.category || "未分类")));
+  }
+  console.log(chalk.gray("\n找到 " + matched.length + " 个匹配的应用包"));
+}
+
+async function handler(args) {
+  const cmd = args[0];
+  if (cmd === "search" || cmd === "s") {
+    await cmdSearch(args[1]);
+  } else {
+    await cmdList();
+  }
+}
+
+function register(reg) {
+  reg("list", (args) => cmdList(), ["l"]);
+  reg("search", (args) => cmdSearch(args[0]), ["s"]);
+}
+
+module.exports = { register };