@atlisp/cli 1.2.0

package/lib/common.js

@@ -0,0 +1,189 @@
+const http = require("http");
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const API_BASE = "http://atlisp.cn";
+const ATLISP_DIR = path.join(os.homedir(), ".atlisp");
+const PKGS_DIR = path.join(os.homedir(), "@lisp", "packages");
+
+const KERNEL_DEFAULT = path.join(os.homedir(), "atlisp", "kernel");
+const SRC_DIR = process.env.ATLISP_KERNEL_SRC || path.join(KERNEL_DEFAULT, "src");
+const TEST_DIR = process.env.ATLISP_KERNEL_TEST || path.join(KERNEL_DEFAULT, "test");
+const KERNEL_ROOT = process.env.ATLISP_KERNEL_ROOT || KERNEL_DEFAULT;
+
+function getKernelSrc() { return SRC_DIR; }
+function getKernelTest() { return TEST_DIR; }
+function getKernelRoot() { return KERNEL_ROOT; }
+
+const installCode = `(progn(vl-load-com)(setq s strcat h "http" o(vlax-create-object (s"win"h".win"h"request.5.1"))v vlax-invoke e eval r read)(v o'open "get" (s h"://atlisp.""cn/@"):vlax-true)(v o'send)(v o'WaitforResponse 1000)(e(r(vlax-get-property o'ResponseText))))`;
+
+function httpGet(path) {
+  return new Promise((resolve, reject) => {
+    const url = API_BASE + path;
+    const client = url.startsWith("https") ? https : http;
+    client.get(url, {
+      headers: {
+        "User-Agent": "Atlisp-User",
+        "Atlisp-Version": "1",
+        "Locale": "zh_CN",
+      },
+    }, (res) => {
+      let data = "";
+      res.on("data", chunk => data += chunk);
+      res.on("end", () => resolve(data));
+    }).on("error", reject);
+  });
+}
+
+function httpPost(url, data, contentType) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const client = url.startsWith("https") ? https : http;
+    const postData = typeof data === "string" ? data : JSON.stringify(data);
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (url.startsWith("https") ? 443 : 80),
+      path: urlObj.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": contentType || "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+      },
+    };
+    const req = client.request(options, (res) => {
+      let body = "";
+      res.on("data", chunk => body += chunk);
+      res.on("end", () => resolve(body));
+    });
+    req.on("error", reject);
+    req.write(postData);
+    req.end();
+  });
+}
+
+function parsePackages(text) {
+  const pkgs = [];
+  const pkgRe = /\(\s*:name\s+"([^"]*)"([^()]*(?:\([^()]*\)[^()]*)*)\s*\)/g;
+  let match;
+  while ((match = pkgRe.exec(text)) !== null) {
+    const name = match[1];
+    const rest = match[2];
+    const fullName = (rest.match(/:full-name\s+"([^"]*)"/) || [])[1] || name;
+    const desc = (rest.match(/:description\s+"([^"]*)"/) || [])[1] || "";
+    const category = (rest.match(/:category\s+"([^"]*)"/) || [])[1] || "";
+    pkgs.push({ name, fullName, description: desc, category });
+  }
+  return pkgs;
+}
+
+function readLocalPackages() {
+  const pkgs = [];
+  try {
+    const inUsePath = path.join(ATLISP_DIR, "pkg-in-use.lst");
+    if (fs.existsSync(inUsePath)) {
+      const names = fs.readFileSync(inUsePath, "utf-8").split("\n").map(s => s.trim()).filter(Boolean);
+      for (const name of names) {
+        const pkgDir = path.join(PKGS_DIR, name);
+        let fullName = name;
+        let description = "";
+        let version = "";
+        const pkgLsp = path.join(pkgDir, "pkg.lsp");
+        if (fs.existsSync(pkgLsp)) {
+          const text = fs.readFileSync(pkgLsp, "utf-8");
+          const nameMatch = text.match(/:full-name\s+"([^"]*)"/);
+          if (nameMatch) fullName = nameMatch[1];
+          const descMatch = text.match(/:description\s+"([^"]*)"/);
+          if (descMatch) description = descMatch[1];
+          const verMatch = text.match(/:version\s+"([^"]*)"/);
+          if (verMatch) version = verMatch[1];
+        }
+        pkgs.push({ name, fullName, description, version, category: "已安装", local: true });
+      }
+    }
+  } catch (e) {}
+  return pkgs;
+}
+
+function simpleDeobfuscate(val) {
+  const PREFIX = "__enc__:";
+  if (!val || typeof val !== "string" || !val.startsWith(PREFIX)) return val;
+  try {
+    const buf = Buffer.from(val.slice(PREFIX.length), "base64");
+    for (let i = 0; i < buf.length; i++) buf[i] = (~buf[i]) & 0xFF;
+    return buf.toString("utf-8");
+  } catch { return val; }
+}
+
+function readConfigCfg() {
+  const cfgPath = path.join(ATLISP_DIR, "config.cfg");
+  if (!fs.existsSync(cfgPath)) return {};
+  const result = {};
+  const text = fs.readFileSync(cfgPath, "utf-8");
+  const re = /^\s*\(@::(\S+)\s+"((?:[^"\\]|\\.)*)"\s*\)\s*$/gm;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    result[m[1]] = simpleDeobfuscate(m[2]);
+  }
+  return result;
+}
+
+function readAtlispConfig() {
+  const configPath = path.join(ATLISP_DIR, "atlisp.json");
+  if (!fs.existsSync(configPath)) return {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const decoded = {};
+    for (const [k, v] of Object.entries(raw)) {
+      decoded[k] = typeof v === "string" ? simpleDeobfuscate(v) : v;
+    }
+    return decoded;
+  } catch (e) { return {}; }
+}
+
+function getAuthToken() {
+  const cfg = readConfigCfg();
+  return cfg["user-token"] || cfg["usertoken"] || readAtlispConfig()["user-token"];
+}
+
+function parseArgs(args) {
+  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 val = args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : true;
+      if (val !== true) i++;
+      opts[key] = val;
+    }
+  }
+  return opts;
+}
+
+function computeChecksum(str) {
+  let sum = 0;
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      sum = ((sum * 31 + c) ^ (sum >> 7)) | 0;
+    }
+  }
+  return String(sum);
+}
+
+function pullLispCode(pkgName) {
+  return "(" + installCode.replace(/\/@/, "/" + pkgName) + ")";
+}
+
+function removeLispCode(pkgName) {
+  return `(@::package-remove "${pkgName}")`;
+}
+
+module.exports = {
+  API_BASE, ATLISP_DIR, PKGS_DIR,
+  installCode,
+  httpGet, httpPost, parsePackages, readLocalPackages,
+  parseArgs, readConfigCfg, readAtlispConfig, getAuthToken,
+  computeChecksum, pullLispCode, removeLispCode,
+  getKernelSrc, getKernelTest, getKernelRoot,
+};

package/lib/deps.js

@@ -0,0 +1,121 @@
+const fs = require("fs");
+const path = require("path");
+const { getKernelSrc } = require("./common");
+
+const KERNEL_SRC = getKernelSrc();
+const KERNEL_ORDER_PATH = path.join(__dirname, "..", "kernel-order.json");
+
+const KERNEL_ORDER = fs.existsSync(KERNEL_ORDER_PATH)
+  ? JSON.parse(fs.readFileSync(KERNEL_ORDER_PATH, "utf-8"))
+  : [];
+
+const DEPENDS_RE = /^;;\s*@depends\s+(.*)$/m;
+const PROVIDES_RE = /^;;\s*@provides\s+(.*)$/m;
+
+function parseDepends(filePath) {
+  if (!fs.existsSync(filePath)) return { deps: [], provides: [] };
+  const content = fs.readFileSync(filePath, "utf-8");
+  const firstLines = content.split("\n").slice(0, 10).join("\n");
+  const depMatch = firstLines.match(DEPENDS_RE);
+  const provMatch = firstLines.match(PROVIDES_RE);
+  const deps = depMatch ? depMatch[1].trim().split(/\s+/).filter(Boolean) : [];
+  const provides = provMatch ? provMatch[1].trim().split(/\s+/).filter(Boolean) : [];
+  return { deps, provides };
+}
+
+function getFileProvides(filePath) {
+  const { provides } = parseDepends(filePath);
+  if (provides.length > 0) return provides;
+  const basename = path.basename(filePath, ".lsp");
+  return [basename];
+}
+
+function getFileDeps(filePath) {
+  const { deps } = parseDepends(filePath);
+  return deps;
+}
+
+function buildDependencyMap() {
+  const map = {};
+  const fileProvides = {};
+
+  for (const f of KERNEL_ORDER) {
+    const fullPath = path.join(KERNEL_SRC, f);
+    const key = path.basename(f, ".lsp");
+    const provides = getFileProvides(fullPath);
+    const deps = getFileDeps(fullPath);
+    map[f] = { deps, provides, key };
+    for (const p of provides) {
+      fileProvides[p] = f;
+    }
+  }
+
+  return { map, fileProvides };
+}
+
+function topologicalSort() {
+  const { map, fileProvides } = buildDependencyMap();
+
+  const visited = new Set();
+  const result = [];
+
+  function visit(file, stack) {
+    if (stack.has(file)) {
+      console.error(`ERROR: Circular dependency detected: ${[...stack, file].join(" -> ")}`);
+      return;
+    }
+    if (visited.has(file)) return;
+    visited.add(file);
+    stack.add(file);
+
+    const info = map[file];
+    for (const dep of info.deps) {
+      const depFile = fileProvides[dep];
+      if (depFile && depFile !== file) {
+        visit(depFile, stack);
+      }
+    }
+
+    stack.delete(file);
+    result.push(file);
+  }
+
+  for (const f of KERNEL_ORDER) {
+    if (!visited.has(f)) {
+      visit(f, new Set());
+    }
+  }
+
+  return result;
+}
+
+function validateOrder() {
+  const sorted = topologicalSort();
+  const current = KERNEL_ORDER;
+
+  let issues = [];
+  for (let i = 0; i < current.length; i++) {
+    const curPos = sorted.indexOf(current[i]);
+    if (curPos !== i) {
+      issues.push(`${current[i]}: position ${i} but dependency order wants ${curPos}`);
+    }
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues,
+    sorted,
+    current,
+  };
+}
+
+module.exports = {
+  KERNEL_ORDER,
+  KERNEL_SRC,
+  parseDepends,
+  getFileProvides,
+  getFileDeps,
+  buildDependencyMap,
+  topologicalSort,
+  validateOrder,
+};

package/lib/docgen.js

@@ -0,0 +1,93 @@
+const fs = require("fs");
+const path = require("path");
+
+const { getKernelSrc } = require("./common");
+const SRC = getKernelSrc();
+
+function extractDocs(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const docs = [];
+  let currentDoc = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const defMatch = line.match(/^\s*\(defun\s+(\S+)\s*/);
+    const docMatch = line.match(/^\s*"([^"]+)"\s*$/);
+
+    if (defMatch) {
+      if (currentDoc) docs.push(currentDoc);
+      currentDoc = { func: defMatch[1], line: i + 1, file: filePath, doc: null };
+    } else if (docMatch && currentDoc && !currentDoc.doc) {
+      currentDoc.doc = docMatch[1];
+    }
+  }
+  if (currentDoc) docs.push(currentDoc);
+  return docs;
+}
+
+function walkDir(dir) {
+  let results = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      results = results.concat(walkDir(full));
+    } else if (entry.name.endsWith(".lsp") && entry.name !== "loader.lsp") {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function main() {
+  const files = walkDir(SRC);
+  let allDocs = [];
+  let undocumented = [];
+
+  for (const file of files) {
+    const docs = extractDocs(file);
+    allDocs = allDocs.concat(docs);
+    for (const d of docs) {
+      if (!d.doc) undocumented.push(d);
+    }
+  }
+
+  console.log(`\nTotal functions documented: ${allDocs.length}`);
+  console.log(`Undocumented functions: ${undocumented.length}`);
+
+  if (undocumented.length > 0) {
+    console.log("\n=== Undocumented Functions ===");
+    for (const u of undocumented) {
+      console.log(`  ${u.func} (${path.relative(SRC, u.file)}:${u.line})`);
+    }
+  }
+
+  const md = [];
+  md.push("# @lisp API Reference\n");
+  md.push(`Auto-generated from ${allDocs.length} function definitions.\n`);
+  md.push(`- **Total functions**: ${allDocs.length}`);
+  md.push(`- **Documented**: ${allDocs.length - undocumented.length}`);
+  md.push(`- **Undocumented**: ${undocumented.length}\n`);
+  md.push("---\n");
+
+  const categorized = {};
+  for (const d of allDocs) {
+    const cat = d.func.includes(":") ? d.func.split(":")[0] : "core";
+    if (!categorized[cat]) categorized[cat] = [];
+    categorized[cat].push(d);
+  }
+
+  for (const [cat, funcs] of Object.entries(categorized).sort()) {
+    md.push(`## ${cat}\n`);
+    for (const f of funcs) {
+      md.push(`- \`${f.func}\` — ${f.doc || "*no documentation*"}`);
+    }
+    md.push("");
+  }
+
+  const outPath = path.join(__dirname, "..", "API.md");
+  fs.writeFileSync(outPath, md.join("\n"), "utf-8");
+  console.log(`\nAPI.md written (${allDocs.length} functions, ${Object.keys(categorized).length} categories)`);
+}
+
+main();

package/lib/find.js

@@ -0,0 +1,154 @@
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const { resolveAppId, isWindows } = require("./cad");
+const { gatherDwgs } = require("./batch");
+
+const CAD_TABLES = [
+  "Blocks", "Dictionaries", "DimStyles", "Groups", "Layers",
+  "Layouts", "Linetypes", "Materials", "TextStyles", "Viewports", "Views",
+];
+
+function normalizeTable(table) {
+  if (!table) return "Blocks";
+  const t = table.toLowerCase().replace(/s$/, "") + "s";
+  for (const ct of CAD_TABLES) {
+    if (ct.toLowerCase() === t) return ct;
+  }
+  return null;
+}
+
+function findPS(appId, profile, dwgList, table, name) {
+  return `
+$dwgs = @(${dwgList.map(d => `'${d.replace(/'/g, "''")}'`).join(", ")})
+$appId = "${resolveAppId(appId)}"
+$profile = "${profile || ""}"
+$table = "${table}"
+$name = "${name.replace(/"/g, '`"')}"
+$total = $dwgs.Count
+$i = 0
+$found = @()
+
+$acad = $null
+try { $acad = [System.Runtime.InteropServices.Marshal]::GetActiveObject($appId) } catch {}
+if (-not $acad) { $acad = New-Object -ComObject $appId }
+
+try {
+  if ($profile -ne "") {
+    $profiles = $acad.Preferences.Profiles.GetAllProfileNames()
+    if ($profiles -contains $profile) { $acad.Preferences.Profiles.ActiveProfile = $profile }
+  }
+  $acad.Visible = $false
+  if ($acad.Documents.Count -eq 0) { $acad.Documents.Add() }
+  Start-Sleep -Seconds 3
+
+  while ($acad.Documents.Count -gt 0) {
+    try { $acad.ActiveDocument.Close($false) } catch {}
+  }
+
+  foreach ($dwg in $dwgs) {
+    $i++
+    try {
+      $doc = $acad.Documents.Open($dwg, $true)
+      Start-Sleep -Seconds 2
+      $tables = $doc.$table
+      $names = @()
+      $x = 0
+      while ($x -lt $tables.Count) {
+        $names += $tables.Item($x).Name
+        $x++
+      }
+      $match = $false
+      foreach ($n in $names) {
+        if ($n -like "*$name*") { $match = $true; break }
+      }
+      if ($match) {
+        $found += $dwg
+      }
+      $doc.Close($false)
+    } catch {
+      Write-Output "ERROR: $dwg - $($_.Exception.Message)"
+    }
+    Write-Output "PROGRESS: $i/$total"
+  }
+} catch {
+  Write-Output "FATAL: $($_.Exception.Message)"
+} finally {
+  try { if ($acad) { $acad.Quit() } } catch {}
+}
+
+Write-Output "RESULTS:"
+foreach ($f in $found) { Write-Output $f }
+Write-Output "COUNT: $($found.Count)"
+`;
+}
+
+async function find(options) {
+  if (!isWindows()) {
+    console.error("find 命令仅支持 Windows CAD COM 自动化。");
+    return false;
+  }
+
+  const { path: predir, table, name, mt, appId, profile } = options;
+
+  if (!name) {
+    console.error("错误: 请使用 --name 指定要查找的元素名称。");
+    return false;
+  }
+
+  const normTable = normalizeTable(table);
+  if (!normTable) {
+    console.error("错误: 不支持的表名。支持: " + CAD_TABLES.join(", "));
+    return false;
+  }
+
+  let dwgs = gatherDwgs(predir);
+  if (dwgs.length === 0) {
+    console.error("错误: 未找到 DWG 文件。请使用 --path 指定包含 DWG 的目录。");
+    return false;
+  }
+
+  console.log("  查找 " + normTable + " 中包含 '" + name + "' 的 DWG 文件...");
+  console.log("  扫描 " + dwgs.length + " 个文件...");
+
+  const PS = findPS(appId, profile, dwgs, normTable, name);
+  const scriptPath = path.join(os.tmpdir(), "atlisp-find-" + Date.now() + ".ps1");
+  fs.writeFileSync(scriptPath, PS, "utf-8");
+
+  try {
+    const out = execSync(`powershell -ExecutionPolicy Bypass -File "${scriptPath}"`, {
+      encoding: "utf-8",
+      timeout: Math.max(60000, dwgs.length * 10000),
+      maxBuffer: 1024 * 1024,
+    });
+    const lines = out.split("\n").filter(Boolean);
+    const results = [];
+    let inResults = false;
+    for (const line of lines) {
+      if (line === "RESULTS:") { inResults = true; continue }
+      if (line.startsWith("COUNT:")) {
+        const count = parseInt(line.split(":")[1].trim());
+        if (count === 0) {
+          console.log("  未找到匹配的 DWG 文件。");
+        } else {
+          console.log("\n  找到 " + count + " 个匹配文件:");
+          for (const r of results) console.log("    " + r);
+        }
+        continue;
+      }
+      if (inResults) { results.push(line); continue }
+      if (line.startsWith("PROGRESS:") || line.startsWith("ERROR:") || line.startsWith("FATAL:")) {
+        console.log("  " + line);
+      }
+    }
+    return true;
+  } catch (e) {
+    console.error("  查找失败: " + e.message);
+    return false;
+  } finally {
+    try { fs.unlinkSync(scriptPath); } catch (e) {}
+  }
+}
+
+module.exports = { find, CAD_TABLES, normalizeTable };