@atlisp/cli 1.2.0

package/.github/workflows/publish.yml

@@ -0,0 +1,18 @@
+name: Publish to npm
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          registry-url: "https://registry.npmjs.org"
+      - run: npm ci
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/test.yml

@@ -0,0 +1,14 @@
+name: Test
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: npm
+      - run: npm ci
+      - run: npm test

package/README.md

@@ -0,0 +1,88 @@
+# @atlisp/cli — @lisp 命令行工具
+
+在 AutoCAD、ZWCAD、GStarCAD、BricsCAD 中管理 AutoLISP 包、构建内核、运行测试的命令行工具。
+
+## 安装
+
+```sh
+npm install -g @atlisp/cli
+```
+
+## 用法
+
+```sh
+atlisp <命令> [参数]
+```
+
+### 包管理
+
+| 命令 | 说明 |
+|------|------|
+| `atlisp install` | 安装 @lisp Core 到 CAD |
+| `atlisp pull <包名>` | 安装一个包 |
+| `atlisp remove <包名>` | 卸载一个包 |
+| `atlisp list` | 列出本地包 |
+| `atlisp search <关键词>` | 搜索远程包 |
+
+### 内核开发
+
+| 命令 | 说明 |
+|------|------|
+| `atlisp build` | 构建 `@lisp_u.lsp`（需要 `ATLISP_KERNEL_SRC`） |
+| `atlisp build-module <名>` | 构建单个模块 |
+| `atlisp watch` | 监听源文件变更自动构建 |
+| `atlisp lint` | AutoLISP 代码检查 |
+| `atlisp test` | 在 SBCL 中运行语法测试 |
+| `atlisp test --platform cad` | 在 CAD 中运行测试（需 CAD + MCP） |
+| `atlisp init --template module <名>` | 创建新模块脚手架 |
+
+### 配置与诊断
+
+| 命令 | 说明 |
+|------|------|
+| `atlisp config list` | 查看配置 |
+| `atlisp config set <key> <val>` | 设置配置 |
+| `atlisp login` | 登录 atlisp.cn |
+| `atlisp doctor` | 环境诊断 |
+| `atlisp check` | CAD 连接检查 |
+
+### 工具
+
+| 命令 | 说明 |
+|------|------|
+| `atlisp batch --path <dir> --expr <lisp>` | 批量 DWG 处理 |
+| `atlisp find --name <pattern>` | 在 DWG 中搜索元素 |
+| `atlisp qrcode <text>` | 生成 QR 码 |
+| `atlisp dcl-migrate <dcl文件>` | 转换 DCL 到 DSL 格式 |
+
+## 环境变量
+
+| 变量 | 说明 | 默认值 |
+|------|------|--------|
+| `ATLISP_KERNEL_SRC` | 内核源码目录 | `~/atlisp/kernel/src` |
+| `ATLISP_KERNEL_TEST` | 内核测试目录 | `~/atlisp/kernel/test` |
+| `ATLISP_KERNEL_ROOT` | 内核根目录 | `~/atlisp/kernel` |
+
+## 开发
+
+```sh
+git clone https://gitee.com/atlisp/atlisp-cli.git
+cd atlisp-cli
+npm install
+npm test          # 运行 Jest 测试
+node atlisp.js    # 交互模式
+```
+
+## 从 kernel 仓库迁移
+
+`@atlisp/cli` 原来位于 `atlisp/kernel/tools/cli/atlisp/`。现已独立为单独项目。
+
+迁移后，kernel 仓库不再自带 CLI 工具，但可通过以下方式使用：
+
+1. **全局安装**：`npm install -g @atlisp/cli`
+2. **npx 直接使用**：`npx @atlisp/cli build`
+3. **原位使用**：kernel 仓库的 Makefile 会自动探测可用方式
+
+## 许可证
+
+ISC

package/__tests__/__snapshots__/cli.test.js.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Snapshot: package list output parsePackages output snapshot 1`] = `
+[
+  {
+    "category": "工具",
+    "description": "基础工具集",
+    "fullName": "基础工具",
+    "name": "base",
+  },
+]
+`;

package/__tests__/build.test.js

@@ -0,0 +1,48 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const CLI = path.join(__dirname, "..", "atlisp.js");
+const { getKernelSrc } = require("../lib/common");
+const KERNEL_ORDER = (() => { try { return require("../kernel-order.json"); } catch(e) { return []; } })();
+
+describe("Build system", () => {
+  test("KERNEL_ORDER contains scheduler", () => {
+    expect(KERNEL_ORDER).toContain("sub-system/scheduler.lsp");
+  });
+
+  test("all KERNEL_ORDER files exist", () => {
+    const srcDir = getKernelSrc();
+    for (const f of KERNEL_ORDER) {
+      const fullPath = path.join(srcDir, f);
+      expect(fs.existsSync(fullPath)).toBe(true);
+    }
+  });
+
+  test("KERNEL_ORDER has no duplicates", () => {
+    const seen = new Set();
+    for (const f of KERNEL_ORDER) {
+      expect(seen.has(f)).toBe(false);
+      seen.add(f);
+    }
+  });
+
+  test("modules with subdirs have matching subfiles", () => {
+    const modulesDir = path.join(path.dirname(getKernelSrc()), "modules");
+    const entries = fs.readdirSync(modulesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory());
+    expect(dirs.length).toBeGreaterThan(0);
+  });
+});
+
+describe("CLI help", () => {
+  test("--help exits with code 0", () => {
+    const result = execSync(`node ${CLI} --help`, { encoding: "utf-8" });
+    expect(result).toContain("@atlisp/cli v");
+  });
+
+  test("--version outputs version", () => {
+    const result = execSync(`node ${CLI} --version`, { encoding: "utf-8" });
+    expect(result).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});

package/__tests__/cli.test.js

@@ -0,0 +1,246 @@
+const nock = require("nock");
+const {
+  pullLispCode, removeLispCode, installCode, parsePackages, computeChecksum,
+  resolveAppId, isWindows, CAD_TABLES, normalizeTable,
+  httpGet, API_BASE,
+} = require("../lib/atlisp");
+
+describe("CLI Commands", () => {
+  const validCommands = ["install", "pull", "remove", "list", "search", "batch", "find", "check", "test", "build", "build-module", "checksum"];
+
+  test("should recognize all commands", () => {
+    expect(validCommands).toContain("install");
+    expect(validCommands).toContain("pull");
+    expect(validCommands).toContain("remove");
+    expect(validCommands).toContain("list");
+    expect(validCommands).toContain("search");
+    expect(validCommands).toContain("batch");
+    expect(validCommands).toContain("find");
+    expect(validCommands).toContain("check");
+  });
+
+  test("should recognize short aliases", () => {
+    const aliases = { i: "install", p: "pull", rm: "remove", l: "list", s: "search", b: "build", t: "test", cs: "checksum" };
+    for (const [alias, cmd] of Object.entries(aliases)) {
+      expect(validCommands).toContain(cmd);
+    }
+  });
+
+  test("should reject unknown commands", () => {
+    const unknownCmds = ["upgrade", "help", "xyz"];
+    unknownCmds.forEach(cmd => {
+      expect(validCommands.includes(cmd)).toBe(false);
+    });
+  });
+});
+
+describe("Install Code", () => {
+  test("should generate valid install code", () => {
+    expect(installCode).toContain("vl-load-com");
+    expect(installCode).toContain("atlisp");
+    expect(installCode).toContain("/@");
+    expect(installCode.length).toBeGreaterThan(100);
+  });
+
+  test("should generate correct pull code for package", () => {
+    const code = pullLispCode("base");
+    expect(code).toContain("vl-load-com");
+    expect(code).toContain("/base");
+    expect(code).not.toContain("/@");
+  });
+
+  test("pull code should wrap in outer parens", () => {
+    const code = pullLispCode("at-pm");
+    expect(code.startsWith("(")).toBe(true);
+    expect(code.endsWith("))")).toBe(true);
+  });
+
+  test("should handle package name with hyphens", () => {
+    const code = pullLispCode("my-package");
+    expect(code).toContain("/my-package");
+  });
+});
+
+describe("Remove Code", () => {
+  test("should generate remove code", () => {
+    const code = removeLispCode("base");
+    expect(code).toContain("base");
+    expect(code).toContain("package-remove");
+  });
+
+  test("should handle package name with hyphens", () => {
+    const code = removeLispCode("my-package");
+    expect(code).toContain("my-package");
+  });
+});
+
+describe("Package Parsing", () => {
+  test("should parse S-expression package list", () => {
+    const text = `((:name "base" :full-name "基础工具" :author "VitalGG" :version "1.2" :description "基础工具集" :category "工具" :required nil :url nil :files ("base-whole") :opensource 1 :free T)
+ (:name "at-pm" :full-name "图号管理" :author "VitalGG" :description "图号管理工具" :category "管理" :required nil :files ("at-pm/entry") :opensource 1 :free T))`;
+    const pkgs = parsePackages(text);
+    expect(pkgs).toHaveLength(2);
+    expect(pkgs[0].name).toBe("base");
+    expect(pkgs[0].fullName).toBe("基础工具");
+    expect(pkgs[0].category).toBe("工具");
+    expect(pkgs[1].name).toBe("at-pm");
+    expect(pkgs[1].fullName).toBe("图号管理");
+    expect(pkgs[1].category).toBe("管理");
+  });
+
+  test("should handle empty input", () => {
+    expect(parsePackages("")).toEqual([]);
+    expect(parsePackages("  ")).toEqual([]);
+    expect(parsePackages("()")).toEqual([]);
+  });
+
+  test("should handle packages with missing fields", () => {
+    const text = `((:name "simple" :version "1.0"))`;
+    const pkgs = parsePackages(text);
+    expect(pkgs).toHaveLength(1);
+    expect(pkgs[0].name).toBe("simple");
+    expect(pkgs[0].fullName).toBe("simple");
+    expect(pkgs[0].description).toBe("");
+    expect(pkgs[0].category).toBe("");
+  });
+
+  test("should handle category-only packages", () => {
+    const text = `((:name "arch" :category "建筑" :full-name "建筑工具"))`;
+    const pkgs = parsePackages(text);
+    expect(pkgs[0].category).toBe("建筑");
+    expect(pkgs[0].fullName).toBe("建筑工具");
+  });
+});
+
+describe("Checksum", () => {
+  test("should compute consistent checksum", () => {
+    const h1 = computeChecksum("hello");
+    const h2 = computeChecksum("hello");
+    expect(h1).toBe(h2);
+  });
+
+  test("should produce different checksums for different content", () => {
+    const h1 = computeChecksum("hello");
+    const h2 = computeChecksum("world");
+    expect(h1).not.toBe(h2);
+  });
+
+  test("checksum should be numeric string", () => {
+    const h = computeChecksum("test content here");
+    expect(h).toMatch(/^-?\d+$/);
+  });
+});
+
+describe("CAD Platform Resolution", () => {
+  test("should default to AutoCAD", () => {
+    expect(resolveAppId()).toBe("AutoCAD.Application");
+    expect(resolveAppId("")).toBe("AutoCAD.Application");
+    expect(resolveAppId("auto")).toBe("AutoCAD.Application");
+  });
+
+  test("should resolve platform names", () => {
+    expect(resolveAppId("autocad")).toBe("AutoCAD.Application");
+    expect(resolveAppId("zwcad")).toBe("ZWCAD.Application");
+    expect(resolveAppId("gstarcad")).toBe("GStarCAD.Application");
+    expect(resolveAppId("bricscad")).toBe("BricscadApp.AcadApplication");
+  });
+
+  test("should pass through custom app IDs", () => {
+    expect(resolveAppId("AutoCAD.Application.24")).toBe("AutoCAD.Application.24");
+  });
+});
+
+describe("Platform Detection", () => {
+  test("isWindows should return boolean", () => {
+    expect(typeof isWindows()).toBe("boolean");
+  });
+});
+
+describe("CAD Tables", () => {
+  test("should have all expected table names", () => {
+    expect(CAD_TABLES).toContain("Blocks");
+    expect(CAD_TABLES).toContain("Layers");
+    expect(CAD_TABLES).toContain("TextStyles");
+    expect(CAD_TABLES).toContain("Linetypes");
+  });
+
+  test("normalizeTable should default to Blocks", () => {
+    expect(normalizeTable()).toBe("Blocks");
+    expect(normalizeTable("")).toBe("Blocks");
+  });
+
+  test("normalizeTable should normalize names", () => {
+    expect(normalizeTable("block")).toBe("Blocks");
+    expect(normalizeTable("Blocks")).toBe("Blocks");
+    expect(normalizeTable("layer")).toBe("Layers");
+    expect(normalizeTable("textstyle")).toBe("TextStyles");
+  });
+
+  test("normalizeTable should reject unknown tables", () => {
+    expect(normalizeTable("xyz")).toBeNull();
+  });
+});
+
+describe("HTTP API", () => {
+  afterEach(() => nock.cleanAll());
+
+  test("httpGet should fetch package list", async () => {
+    const mockData = `((:name "base" :full-name "基础工具" :category "工具"))`;
+    nock(API_BASE)
+      .get("/packages-list?edition=stable")
+      .reply(200, mockData);
+
+    const text = await httpGet("/packages-list?edition=stable");
+    expect(text).toBe(mockData);
+    const pkgs = parsePackages(text);
+    expect(pkgs).toHaveLength(1);
+    expect(pkgs[0].name).toBe("base");
+  });
+
+  test("httpGet should handle network errors", async () => {
+    nock(API_BASE)
+      .get("/packages-list?edition=stable")
+      .replyWithError("Network error");
+
+    await expect(httpGet("/packages-list?edition=stable")).rejects.toThrow();
+  });
+
+  test("httpGet should handle 404", async () => {
+    nock(API_BASE)
+      .get("/nonexistent")
+      .reply(404, "Not found");
+
+    const text = await httpGet("/nonexistent");
+    expect(text).toBe("Not found");
+  });
+
+  test("httpGet should fetch large package list", async () => {
+    const pkgs = Array.from({ length: 20 }, (_, i) =>
+      `(:name "pkg${i}" :full-name "Package ${i}" :category "test")`
+    ).join("\n ");
+    const mockData = `(${pkgs})`;
+    nock(API_BASE)
+      .get("/packages-list?edition=stable")
+      .reply(200, mockData);
+
+    const text = await httpGet("/packages-list?edition=stable");
+    const result = parsePackages(text);
+    expect(result).toHaveLength(20);
+    expect(result[0].name).toBe("pkg0");
+    expect(result[19].name).toBe("pkg19");
+  });
+});
+
+describe("API_BASE configuration", () => {
+  test("API_BASE should point to atlisp.cn", () => {
+    expect(API_BASE).toMatch(/atlisp\.cn/);
+  });
+});
+
+describe("Snapshot: package list output", () => {
+  test("parsePackages output snapshot", () => {
+    const text = `((:name "base" :full-name "基础工具" :category "工具" :description "基础工具集"))`;
+    const pkgs = parsePackages(text);
+    expect(pkgs).toMatchSnapshot();
+  });
+});

package/__tests__/config.test.js

@@ -0,0 +1,71 @@
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+// Mock homedir before requiring config
+const TEST_HOME = path.join(os.tmpdir(), "atlisp-test-config-" + Date.now());
+const realHomedir = os.homedir;
+os.homedir = () => TEST_HOME;
+
+const config = require("../commands/config");
+
+afterAll(() => {
+  os.homedir = realHomedir;
+  fs.rmSync(TEST_HOME, { recursive: true, force: true });
+});
+
+describe("Config system", () => {
+  test("readConfigCfg returns empty when no file", () => {
+    const cfg = config.readConfigCfg();
+    expect(cfg).toEqual({});
+  });
+
+  test("readAtlispConfig returns empty when no file", () => {
+    const cfg = config.readAtlispConfig();
+    expect(cfg).toEqual({});
+  });
+
+  test("getAllConfig returns merged config", () => {
+    const all = config.getAllConfig();
+    expect(all).toBeDefined();
+    expect(typeof all).toBe("object");
+  });
+
+  test("saveAuthToBoth writes to both config stores", () => {
+    config.saveAuthToBoth("test@example.com", "tok_12345");
+
+    const cfgCfg = config.readConfigCfg();
+    expect(cfgCfg["user-email"]).toBe("test@example.com");
+    expect(cfgCfg["user-token"]).toBe("tok_12345");
+
+    const jsonCfg = config.readAtlispConfig();
+    expect(jsonCfg["user-email"]).toBe("test@example.com");
+    expect(jsonCfg["user-token"]).toBe("tok_12345");
+
+    // token should be obfuscated in raw config.cfg
+    const rawCfg = fs.readFileSync(
+      path.join(TEST_HOME, ".atlisp", "config.cfg"),
+      "utf-8"
+    );
+    expect(rawCfg).toContain("__enc__:");
+    expect(rawCfg).not.toContain("tok_12345");
+
+    // token should be obfuscated in raw atlisp.json
+    const rawJson = fs.readFileSync(
+      path.join(TEST_HOME, ".atlisp", "atlisp.json"),
+      "utf-8"
+    );
+    expect(rawJson).toContain("__enc__:");
+    expect(rawJson).not.toContain("tok_12345");
+  });
+
+  test("getAuthToken deobfuscates token", () => {
+    const token = config.getAuthToken();
+    expect(token).toBe("tok_12345");
+  });
+
+  test("getAuthEmail returns email", () => {
+    const email = config.getAuthEmail();
+    expect(email).toBe("test@example.com");
+  });
+});

package/__tests__/deps.test.js

@@ -0,0 +1,64 @@
+const path = require("path");
+const deps = require("../lib/deps");
+
+describe("Dependency analysis", () => {
+  test("buildDependencyMap returns map for all kernel files", () => {
+    const { map, fileProvides } = deps.buildDependencyMap();
+    expect(Object.keys(map).length).toBe(deps.KERNEL_ORDER.length);
+    expect(Object.keys(fileProvides).length).toBeGreaterThan(0);
+  });
+
+  test("topologicalSort returns all files", () => {
+    const sorted = deps.topologicalSort();
+    expect(sorted.length).toBe(deps.KERNEL_ORDER.length);
+  });
+
+  test("topologicalSort places roots first", () => {
+    const sorted = deps.topologicalSort();
+    // platform-api has no deps, should be early
+    const idx = sorted.indexOf("platform-api.lsp");
+    expect(idx).toBeGreaterThanOrEqual(0);
+    expect(idx).toBeLessThan(5);
+  });
+
+  test("validateOrder passes", () => {
+    const result = deps.validateOrder();
+    expect(result.valid).toBe(true);
+    expect(result.issues.length).toBe(0);
+  });
+
+  test("no circular dependencies", () => {
+    // topologicalSort prints error for cycles, but doesn't throw
+    // We verify by checking sorted order is complete and valid
+    const sorted = deps.topologicalSort();
+    const { map, fileProvides } = deps.buildDependencyMap();
+    
+    // Verify all deps of each file appear before it in sorted order
+    const position = {};
+    sorted.forEach((f, i) => { position[f] = i; });
+    
+    for (const [f, info] of Object.entries(map)) {
+      for (const dep of info.deps) {
+        const depFile = fileProvides[dep];
+        if (depFile && depFile !== f) {
+          expect(position[f]).toBeGreaterThan(position[depFile]);
+        }
+      }
+    }
+  });
+
+  test("parseDepends handles files without annotations", () => {
+    const tmpFile = path.join(__dirname, "_tmp_test_no_annot.lsp");
+    require("fs").writeFileSync(tmpFile, "(princ \"hello\")\n");
+    const result = deps.parseDepends(tmpFile);
+    expect(result.deps).toEqual([]);
+    expect(result.provides).toEqual([]);
+    require("fs").unlinkSync(tmpFile);
+  });
+
+  test("validateOrder detects missing files", () => {
+    // Should not crash for missing files
+    const result = deps.validateOrder();
+    expect(result).toHaveProperty("valid");
+  });
+});

package/__tests__/index.test.js

@@ -0,0 +1,63 @@
+const lib = require("../index");
+
+describe("atlisp library", () => {
+  test("returns expected string", () => {
+    expect(lib.atlisp()).toBe("atlisp - CAD package manager!");
+  });
+});
+
+describe("Library exports", () => {
+  test("should export all common functions", () => {
+    expect(typeof lib.httpGet).toBe("function");
+    expect(typeof lib.parsePackages).toBe("function");
+    expect(typeof lib.readLocalPackages).toBe("function");
+    expect(typeof lib.computeChecksum).toBe("function");
+    expect(typeof lib.pullLispCode).toBe("function");
+    expect(typeof lib.removeLispCode).toBe("function");
+  });
+
+  test("should export CAD functions", () => {
+    expect(typeof lib.checkCAD).toBe("function");
+    expect(typeof lib.installAtLisp).toBe("function");
+    expect(typeof lib.pull).toBe("function");
+    expect(typeof lib.remove).toBe("function");
+    expect(typeof lib.resolveAppId).toBe("function");
+    expect(typeof lib.isWindows).toBe("function");
+  });
+
+  test("should export batch and find", () => {
+    expect(typeof lib.batch).toBe("function");
+    expect(typeof lib.find).toBe("function");
+  });
+
+  test("should export CAD_TABLES and installCode", () => {
+    expect(Array.isArray(lib.CAD_TABLES)).toBe(true);
+    expect(typeof lib.installCode).toBe("string");
+  });
+
+  test("should export constants", () => {
+    expect(typeof lib.API_BASE).toBe("string");
+    expect(typeof lib.ATLISP_DIR).toBe("string");
+    expect(typeof lib.PKGS_DIR).toBe("string");
+  });
+});
+
+describe("CLI Commands", () => {
+  const validCommands = ["install", "pull", "remove", "list", "search", "batch", "find", "check", "test", "build"];
+
+  test("should recognize new commands", () => {
+    expect(validCommands).toContain("remove");
+    expect(validCommands).toContain("batch");
+    expect(validCommands).toContain("find");
+    expect(validCommands).toContain("check");
+  });
+});
+
+describe("Package Validation", () => {
+  test("should validate package name format", () => {
+    const validNames = ["at-pm", "base", "network", "userman"];
+    validNames.forEach(name => {
+      expect(name).toMatch(/^[a-z-]+$/);
+    });
+  });
+});

package/__tests__/lint.test.js

@@ -0,0 +1,58 @@
+const path = require("path");
+const fs = require("fs");
+
+describe("Lint system", () => {
+  test("@atlisp/lint module loads", () => {
+    const lintMod = require("@atlisp/lint/dist/index");
+    expect(lintMod).toHaveProperty("main");
+  });
+
+  test("lintFiles API works on small files", () => {
+    const { lintFiles } = require("@atlisp/lint/dist/runner");
+    const { loadConfig } = require("@atlisp/lint/dist/config");
+    const config = loadConfig();
+
+    // Create a temp file with known issues
+    const tmpDir = fs.mkdtempSync(path.join(require("os").tmpdir(), "lint-test-"));
+    const tmpFile = path.join(tmpDir, "test.lsp");
+    fs.writeFileSync(tmpFile, `(defun foo (x)
+  "test fn"
+  (print x)
+  nil)
+`);
+    const issues = lintFiles([tmpFile], config, tmpDir);
+    expect(Array.isArray(issues)).toBe(true);
+
+    // Cleanup
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("lintFiles handles empty file", () => {
+    const { lintFiles } = require("@atlisp/lint/dist/runner");
+    const { loadConfig } = require("@atlisp/lint/dist/config");
+    const config = loadConfig();
+
+    const tmpDir = fs.mkdtempSync(path.join(require("os").tmpdir(), "lint-test-"));
+    const tmpFile = path.join(tmpDir, "empty.lsp");
+    fs.writeFileSync(tmpFile, "");
+
+    const issues = lintFiles([tmpFile], config, tmpDir);
+    expect(Array.isArray(issues)).toBe(true);
+
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("collectLspFiles returns .lsp files", () => {
+    const { collectLspFiles } = require("../commands/lint");
+    const tmpDir = fs.mkdtempSync(path.join(require("os").tmpdir(), "lint-collect-"));
+    fs.writeFileSync(path.join(tmpDir, "a.lsp"), "");
+    fs.writeFileSync(path.join(tmpDir, "b.txt"), "not lisp");
+    fs.writeFileSync(path.join(tmpDir, "c.lsp"), "");
+
+    const files = collectLspFiles(tmpDir);
+    expect(files.length).toBe(2);
+    expect(files.every(f => f.endsWith(".lsp"))).toBe(true);
+
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+});