@atlisp/lint 0.1.23 → 0.1.24

package/dist/atlisp-lint.default.json

@@ -0,0 +1,90 @@
+{
+  "locale": "zh",
+  "source": {
+    "globs": ["**/*.lsp"],
+    "exclude": ["**/node_modules/**", "**/vendor/**", "**/.git/**"]
+  },
+  "checks": {
+    "parens": "error",
+    "encoding": "warn",
+    "cl_syntax": "warn",
+    "quit_exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn",
+    "vlax_without_loading": "off",
+    "token_in_url": "warn",
+    "open_without_close": "warn",
+    "bare_function_names": "off",
+    "line_length": "warn",
+    "function_complexity": "warn",
+    "parameter_naming": "warn",
+    "unused_variable": "warn",
+    "missing_doc": "warn",
+    "error_handling": "warn",
+    "global_naming": "warn",
+    "extra_parens": "warn",
+    "arg_count": "warn",
+    "strcat_usage": "warn",
+    "cond_simplify": "warn",
+    "redundant_progn": "warn",
+    "quote_style": "warn",
+    "eq_usage": "warn",
+    "lambda_syntax": "warn",
+    "comment_style": "warn",
+    "empty_catch": "warn",
+    "nth_usage": "warn",
+    "append_single": "warn",
+    "setq_multiple": "warn",
+    "function_order": "off",
+    "magic_number": "off",
+    "mixed_indent": "warn",
+    "long_function_call": "warn",
+    "no_return": "warn",
+    "shadow_builtin": "warn",
+    "dynamic_doc": "warn",
+    "loop_optimization": "off",
+    "type_check": "off",
+    "redundant_if": "warn",
+    "trailing_whitespace": "warn",
+    "module_registration": "off",
+    "namespace_header": "off"
+  },
+  "line_length": {
+    "max": 100,
+    "tab_width": 2
+  },
+  "function_complexity": {
+    "max_lines": 60,
+    "max_nesting": 6
+  },
+  "cl_syntax": {
+    "keywords": ["&key"]
+  },
+  "dangerous_calls": {
+    "quit": "error",
+    "exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn"
+  },
+  "module_registration": {
+    "severity": "off",
+    "patterns": [],
+    "dirs": ["modules"]
+  },
+  "namespace_header": {
+    "severity": "off",
+    "package": "",
+    "deps": [],
+    "search_lines": 15
+  },
+  "bare_function_names": {
+    "allowlist": ["T", "nil"],
+    "namespace_pattern": "^[a-z]+:"
+  },
+  "sbcl": {
+    "walk_exclude": [".vscode", "vendor", ".git"],
+    "defmacro_allow_files": ["compat-cl"]
+  }
+}

package/dist/checks/arg-count.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkArgCount(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
     for (const defun of defuns) {
         if (!defun.children || defun.children.length < 3)

package/dist/checks/assoc-without-cdr.js

@@ -5,7 +5,7 @@ exports.checkAssocWithoutCdrAst = checkAssocWithoutCdrAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkAssocWithoutCdr(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkAssocWithoutCdrAst(ast, file);
 }
 function checkAssocWithoutCdrAst(ast, file) {

package/dist/checks/cond-duplicate.js

@@ -18,7 +18,7 @@ function condKey(node) {
     return '';
 }
 function checkCondDuplicate(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkCondDuplicateAst(ast, file);
 }
 function checkCondDuplicateAst(ast, file) {

package/dist/checks/constant-condition.js

@@ -7,7 +7,7 @@ const parser_1 = require("@atlisp/parser");
 const CONDITION_FORMS = new Set(['if', 'while']);
 const CONSTANTS = new Set(['T', 'nil']);
 function checkConstantCondition(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkConstantConditionAst(ast, file);
 }
 function checkConstantConditionAst(ast, file) {
@@ -41,8 +41,8 @@ function checkConstantConditionAst(ast, file) {
                 continue;
             const condTest = clause.children[0];
             if (condTest.type === 'symbol' && condTest.name && CONSTANTS.has(condTest.name)) {
-                // Skip last clause with T — that's the standard else/default pattern
-                if (condTest.name === 'T' && i === condNode.children.length - 1)
+                // Skip last clause with T (only when there are multiple clauses — else/default pattern)
+                if (condTest.name === 'T' && i === condNode.children.length - 1 && i > 1)
                     continue;
                 issues.push({
                     file,

package/dist/checks/dangerous-calls.js

@@ -36,7 +36,7 @@ function isFunctionCall(list, name) {
     return list.children[0].type === 'symbol' && list.children[0].name === name;
 }
 function checkDangerousCalls(content, file, config) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkDangerousCallsAst(ast, file, config);
 }
 function checkDangerousCallsAst(ast, file, config) {

package/dist/checks/dangling-defun.js

@@ -40,7 +40,7 @@ const fs = __importStar(require("fs"));
 function checkDanglingDefun(file, allDefuns, allReferences) {
     const issues = [];
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const localDefuns = [];
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {

package/dist/checks/double-not.js

@@ -5,7 +5,7 @@ exports.checkDoubleNotAst = checkDoubleNotAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkDoubleNot(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkDoubleNotAst(ast, file);
 }
 function checkDoubleNotAst(ast, file) {

package/dist/checks/empty-branch.js

@@ -7,7 +7,7 @@ const parser_1 = require("@atlisp/parser");
 // AutoLISP only has `if` for conditional branching; `while` with no body is valid (no-op loop)
 const BRANCH_FORMS = new Set(['if']);
 function checkEmptyBranch(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkEmptyBranchAst(ast, file);
 }
 function checkEmptyBranchAst(ast, file) {

package/dist/checks/empty-catch.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkEmptyCatch(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const catchNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'vl-catch-all-apply'));
     for (const node of catchNodes) {
         if (isInQuote(node))

package/dist/checks/function-complexity.js

@@ -5,7 +5,7 @@ exports.checkFunctionComplexityAst = checkFunctionComplexityAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkFunctionComplexity(content, file, maxLines, maxNesting) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkFunctionComplexityAst(ast, file, maxLines, maxNesting);
 }
 function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {

package/dist/checks/global-naming.js

@@ -25,7 +25,7 @@ function isInsideLocalScope(node) {
 }
 function checkGlobalNaming(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
     for (const form of setqForms) {
         if (!form.children || form.children.length < 2)

package/dist/checks/identical-branches.js

@@ -27,7 +27,7 @@ function astEqual(a, b) {
     return false;
 }
 function checkIdenticalBranches(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkIdenticalBranchesAst(ast, file);
 }
 function checkIdenticalBranchesAst(ast, file) {

package/dist/checks/misplaced-else.js

@@ -5,7 +5,7 @@ exports.checkMisplacedElseAst = checkMisplacedElseAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkMisplacedElse(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkMisplacedElseAst(ast, file);
 }
 function checkMisplacedElseAst(ast, file) {

package/dist/checks/multiple-setq.js

@@ -5,7 +5,7 @@ exports.checkMultipleSetqAst = checkMultipleSetqAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkMultipleSetq(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkMultipleSetqAst(ast, file);
 }
 function checkMultipleSetqAst(ast, file) {

package/dist/checks/no-return.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkNoReturn(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
     for (const defun of defuns) {
         if (!defun.children || defun.children.length < 3)

package/dist/checks/open-close.js

@@ -5,7 +5,7 @@ exports.checkOpenWithoutCloseAst = checkOpenWithoutCloseAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkOpenWithoutClose(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkOpenWithoutCloseAst(ast, file);
 }
 function checkOpenWithoutCloseAst(ast, file) {

package/dist/checks/parameter-naming.js

@@ -5,7 +5,7 @@ exports.checkParameterNamingAst = checkParameterNamingAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkParameterNaming(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkParameterNamingAst(ast, file);
 }
 function checkParameterNamingAst(ast, file) {

package/dist/checks/quote-vs-function.js

@@ -17,7 +17,7 @@ const HIGHER_ORDER_FUNCS = new Set([
     'vl-every',
 ]);
 function checkQuoteVsFunction(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkQuoteVsFunctionAst(ast, file);
 }
 function checkQuoteVsFunctionAst(ast, file) {

package/dist/checks/recursive-call.js

@@ -5,7 +5,7 @@ exports.checkRecursiveCallAst = checkRecursiveCallAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRecursiveCall(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRecursiveCallAst(ast, file);
 }
 /** Forms that provide conditional branching (exit condition for recursion) */

package/dist/checks/redundant-let.js

@@ -5,7 +5,7 @@ exports.checkRedundantLetAst = checkRedundantLetAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantLet(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantLetAst(ast, file);
 }
 function checkRedundantLetAst(ast, file) {

package/dist/checks/redundant-nil-else.js

@@ -5,7 +5,7 @@ exports.checkRedundantNilElseAst = checkRedundantNilElseAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantNilElse(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantNilElseAst(ast, file);
 }
 function checkRedundantNilElseAst(ast, file) {

package/dist/checks/redundant-progn.js

@@ -5,7 +5,7 @@ exports.checkRedundantPrognAst = checkRedundantPrognAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantProgn(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantPrognAst(ast, file);
 }
 function checkRedundantPrognAst(ast, file) {

package/dist/checks/redundant-quotes.js

@@ -5,7 +5,7 @@ exports.checkRedundantQuotesAst = checkRedundantQuotesAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantQuotes(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantQuotesAst(ast, file);
 }
 function checkRedundantQuotesAst(ast, file) {

package/dist/checks/redundant-setq.js

@@ -5,7 +5,7 @@ exports.checkRedundantSetqAst = checkRedundantSetqAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkRedundantSetq(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkRedundantSetqAst(ast, file);
 }
 function checkRedundantSetqAst(ast, file) {

package/dist/checks/self-compare.js

@@ -6,7 +6,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const COMPARE_FUNCTIONS = new Set(['=', '/=', '<', '>', '<=', '>=', 'eq', 'equal']);
 function checkSelfCompare(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkSelfCompareAst(ast, file);
 }
 function checkSelfCompareAst(ast, file) {

package/dist/checks/setq-single-arg.js

@@ -5,7 +5,7 @@ exports.checkSetqSingleArgAst = checkSetqSingleArgAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkSetqSingleArg(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkSetqSingleArgAst(ast, file);
 }
 function checkSetqSingleArgAst(ast, file) {

package/dist/checks/single-arg-and-or.js

@@ -5,7 +5,7 @@ exports.checkSingleArgAndOrAst = checkSingleArgAndOrAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkSingleArgAndOr(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkSingleArgAndOrAst(ast, file);
 }
 function checkSingleArgAndOrAst(ast, file) {

package/dist/checks/undeclared-setq.js

@@ -42,7 +42,7 @@ function findEnclosingDefun(node) {
 }
 function checkUndeclaredSetq(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
     for (const setq of setqForms) {
         if (!setq.children || setq.children.length < 2)

package/dist/checks/unused-catch-result.js

@@ -5,7 +5,7 @@ const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkUnusedCatchResult(content, file) {
     const issues = [];
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const catchNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'vl-catch-all-apply'));
     for (const node of catchNodes) {
         if (isInQuote(node))

package/dist/checks/unused-let.js

@@ -5,7 +5,7 @@ exports.checkUnusedLetBindingAst = checkUnusedLetBindingAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkUnusedLetBinding(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkUnusedLetBindingAst(ast, file);
 }
 function checkUnusedLetBindingAst(ast, file) {

package/dist/checks/unused-local-fun.js

@@ -5,7 +5,7 @@ exports.checkUnusedLocalFunAst = checkUnusedLocalFunAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkUnusedLocalFun(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkUnusedLocalFunAst(ast, file);
 }
 function checkUnusedLocalFunAst(ast, file) {

package/dist/checks/unused-package-dep.js

@@ -40,7 +40,7 @@ const fs = __importStar(require("fs"));
 function checkUnusedPackageDep(file) {
     const issues = [];
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
     if (inPackageNodes.length === 0)
         return issues;

package/dist/checks/unused-param.js

@@ -5,7 +5,7 @@ exports.checkUnusedParameterAst = checkUnusedParameterAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkUnusedParameter(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkUnusedParameterAst(ast, file);
 }
 function checkUnusedParameterAst(ast, file) {

package/dist/checks/unused-variable.js

@@ -5,7 +5,7 @@ exports.checkUnusedVariableAst = checkUnusedVariableAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkUnusedVariable(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkUnusedVariableAst(ast, file);
 }
 function checkUnusedVariableAst(ast, file) {

package/dist/checks/variable-shadow.js

@@ -5,7 +5,7 @@ exports.checkVariableShadowAst = checkVariableShadowAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkVariableShadow(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkVariableShadowAst(ast, file);
 }
 function checkVariableShadowAst(ast, file) {

package/dist/checks/while-constant.js

@@ -5,7 +5,7 @@ exports.checkWhileConstantAst = checkWhileConstantAst;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 function checkWhileConstant(content, file) {
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     return checkWhileConstantAst(ast, file);
 }
 function checkWhileConstantAst(ast, file) {

package/dist/formatters.d.ts

@@ -1,5 +1,4 @@
 import { Issue } from './types';
 export declare function formatDefault(issues: Issue[], fileContents?: Map<string, string>): string;
-export declare function formatHtml(issues: Issue[], errorCount: number, warningCount: number): string;
 export declare function formatJson(issues: Issue[], errorCount?: number, warningCount?: number): string;
 //# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDefault = formatDefault;
-exports.formatHtml = formatHtml;
 exports.formatJson = formatJson;
 const locale_1 = require("./locale");
 const colors = {
@@ -69,21 +68,6 @@ function formatDefault(issues, fileContents) {
     }
     return lines.join('\n');
 }
-function formatHtml(issues, errorCount, warningCount) {
-    let html = `<!DOCTYPE html>
-<html lang="en">
-<head><meta charset="UTF-8"><title>@atlisp/lint Report</title></head>
-<body>
-<h1>@atlisp/lint Report</h1>
-<p>${errorCount} error(s), ${warningCount} warning(s)</p>
-<ul>
-`;
-    for (const iss of issues) {
-        html += `  <li>${iss.severity}: ${iss.file}:${iss.line} — ${iss.message}</li>\n`;
-    }
-    html += '</ul>\n</body>\n</html>';
-    return html;
-}
 function formatJson(issues, errorCount, warningCount) {
     return JSON.stringify({
         issues,

package/dist/lib/lint-sbcl.lisp

@@ -0,0 +1,161 @@
+;; @lisp SBCL Lint — syntax validation via SBCL
+;; Usage: sbcl --script lint-sbcl.lisp <src-dir> <stub-packages.json> <walk-exclude-json> <defmacro-allow-files-json> <locale>
+
+(require :uiop)
+
+(defparameter *errors* 0)
+(defparameter *warnings* 0)
+(defparameter *checked* 0)
+(defparameter *locale* "zh")
+
+;; ── i18n ──────────────────────────────────────────────────────────────
+(defun i18n (key)
+  (cdr (assoc key
+    (if (string= *locale* "zh")
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))))))
+
+;; ── Stub packages from external file ──────────────────────────────────
+(defun load-stub-packages (file-path)
+  (flet ((ensure-pkg (name &optional use-list)
+           (unless (find-package name)
+             (make-package name :use (or use-list '())))))
+    (with-open-file (s file-path :direction :input)
+      (let ((packages (read s)))
+        (dolist (pkg packages)
+          (ensure-pkg (first pkg) (second pkg)))))))
+
+;; ── File walking ──────────────────────────────────────────────────────
+(defun source-files (dir)
+  (sort
+    (remove-if-not
+      (lambda (p)
+        (let ((n (pathname-type p)))
+          (and n (string-equal n "lsp"))))
+      (uiop:directory-files dir))
+    'string< :key #'namestring))
+
+(defun walk-tree (dir exclude-dirs)
+  (let ((result (source-files dir)))
+    (dolist (sub (uiop:subdirectories dir))
+      (let ((name (car (last (pathname-directory sub)))))
+        (unless (find name exclude-dirs :test 'string=)
+          (setf result (append result (walk-tree sub exclude-dirs))))))
+    result))
+
+;; ── Per-file check ────────────────────────────────────────────────────
+(defun check-file (path src-dir defmacro-allow-files)
+  (incf *checked*)
+  (let* ((rel (enough-namestring path src-dir))
+         (fullname (format nil "~a.~a" (pathname-name path) (pathname-type path))))
+    (format t "  ~a ... " rel)
+    (force-output)
+    ;; Syntax check via READ
+    (handler-case
+        (with-open-file (s path :direction :input)
+          (loop for form = (read s nil :eof)
+                until (eq form :eof)))
+      (error (e)
+        (let ((msg (princ-to-string e)))
+          (cond
+            ((search "not found" msg)
+             (format t "~%  [NOTE] ~a: ~a~%" rel (i18n :not-found))
+             (incf *warnings*))
+            (t
+             (format t "~a~%  [ERROR] ~a: ~a~%" (i18n :fail) rel (i18n :syntax-error))
+             (incf *errors*)
+             (return-from check-file))))))
+    ;; Trailing whitespace
+    (with-open-file (s path :direction :input)
+      (loop for line = (read-line s nil nil)
+            for lineno from 1
+            while line
+            when (and (> (length line) 0)
+                      (find (char line (1- (length line))) '(#\Space #\Tab)))
+              do (progn
+                   (format t "~%  [WARN] ~a line ~d: ~a~%" rel lineno (i18n :trailing-ws))
+                   (incf *warnings*))))
+    ;; CL-ism checks: raw content scan
+    (with-open-file (s path :direction :input)
+      (let ((content (make-string (file-length s))))
+        (file-position s 0)
+        (read-sequence content s)
+        (when (search "#(" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :vec-syntax))
+          (incf *warnings*))
+        (when (search "#\\" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :char-syntax))
+          (incf *warnings*))
+        (when (search "#." content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :eval-syntax))
+          (incf *warnings*))
+        (when (and (search "defmacro" content)
+                   (not (some (lambda (s) (search s fullname)) defmacro-allow-files)))
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :defmacro))
+          (incf *warnings*))))
+    (format t "~a~%" (i18n :ok))))
+
+;; ── Main ──────────────────────────────────────────────────────────────
+(defun main ()
+  (let* ((args (uiop:command-line-arguments))
+         (src-dir (first args))
+         (stub-file (second args))
+         (walk-exclude (if (third args)
+                          (read-from-string (third args))
+                          '(".vscode" "test" "experiment" "tools" ".git")))
+         (defmacro-allow (if (fourth args)
+                            (read-from-string (fourth args))
+                            '("compat-cl")))
+         (locale (fifth args)))
+    (when locale (setf *locale* locale))
+    (load-stub-packages stub-file)
+
+    (format t "~%==================================================~%")
+    (format t "~a~%" (i18n :header))
+    (format t "~a: ~a~%" (i18n :source) (namestring (pathname src-dir)))
+    (format t "==================================================~%~%")
+    (setf *errors* 0 *warnings* 0 *checked* 0)
+
+    (let ((files (walk-tree src-dir walk-exclude)))
+      (format t "~a~%~%" (format nil (i18n :found) (length files)))
+      (dolist (f files)
+        (check-file f src-dir defmacro-allow)))
+
+    (format t "~%==================================================~%")
+    (format t "~a: ~d~%" (i18n :scanned) *checked*)
+    (format t "~a: ~d~%" (i18n :errors) *errors*)
+    (format t "~a: ~d~%" (i18n :warnings) *warnings*)
+    (format t "==================================================~%~%")
+    (if (> *errors* 0)
+        (uiop:quit 1)
+        (uiop:quit 0))))
+
+(main)

package/dist/project.js

@@ -44,7 +44,7 @@ const duplicate_defun_1 = require("./checks/duplicate-defun");
 const locale_1 = require("./locale");
 function collectDefuns(file) {
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const results = [];
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
@@ -56,7 +56,7 @@ function collectDefuns(file) {
 }
 function collectReferences(file) {
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const results = [];
     const allCalls = (0, parser_1.astFindAll)(ast, n => {
         if (n.type !== 'list' || !n.children || n.children.length === 0)
@@ -73,7 +73,7 @@ function collectReferences(file) {
 }
 function countFunctionArgs(file) {
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const result = new Map();
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
@@ -102,7 +102,7 @@ function countFunctionArgs(file) {
 }
 function countCallArgs(file) {
     const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const result = new Map();
     const allCalls = (0, parser_1.astFindAll)(ast, n => {
         if (n.type !== 'list' || !n.children || n.children.length === 0)
@@ -122,7 +122,7 @@ function countCallArgs(file) {
 }
 function findModuleDeps(filepath) {
     const content = fs.readFileSync(filepath, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content);
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
     const imports = [];
     const exports = [];
     const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));

package/dist/runner.d.ts

@@ -1,6 +1,5 @@
 import { Issue, LintConfig } from './types';
 export declare function runChecks(content: string, file: string, config: LintConfig): Issue[];
-export declare function runChecksWithVisitorWrapper(content: string, file: string, config: LintConfig): Issue[];
 export declare function lintFiles(files: string[], config: LintConfig, rootDir: string): Issue[];
 export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
 export declare const FIXABLE_RULES: Set<string>;

package/dist/runner.js

@@ -35,7 +35,6 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FIXABLE_RULES = void 0;
 exports.runChecks = runChecks;
-exports.runChecksWithVisitorWrapper = runChecksWithVisitorWrapper;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
 exports.applyFixes = applyFixes;
@@ -100,12 +99,17 @@ function runChecks(content, file, config) {
         const severity = checks[rule];
         if (!severity || severity === 'off')
             return;
-        const results = fn();
-        for (const r of results) {
-            if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
-                issues.push(r);
+        try {
+            const results = fn();
+            for (const r of results) {
+                if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
+                    issues.push(r);
+                }
             }
         }
+        catch {
+            // Check failed, continue with remaining checks
+        }
     }
     function addIssues(ruleIssues) {
         for (const r of ruleIssues) {
@@ -173,17 +177,17 @@ function runChecks(content, file, config) {
     ]);
     const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
     if (needsAst) {
-        const ast = (0, parser_1.parseAst)(content);
-        const visitorIssues = (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
-        addIssues(visitorIssues);
+        try {
+            const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+            const visitorIssues = (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
+            addIssues(visitorIssues);
+        }
+        catch {
+            // AST-based checks are skipped, text-based checks above still report issues
+        }
     }
     return issues;
 }
-function runChecksWithVisitorWrapper(content, file, config) {
-    const disableMap = (0, disable_1.parseDisableComments)(content);
-    const ast = (0, parser_1.parseAst)(content);
-    return (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
-}
 function lintFiles(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
@@ -321,6 +325,7 @@ exports.FIXABLE_RULES = new Set([
 ]);
 function applyFixes(issues, content, filepath) {
     const lines = content.split('\n');
+    const fixedLines = new Set();
     const fixesByRule = new Map();
     for (const iss of issues) {
         if (iss.file !== filepath)
@@ -330,7 +335,6 @@ function applyFixes(issues, content, filepath) {
         fixesByRule.set(iss.rule, set);
     }
     const fixableRules = exports.FIXABLE_RULES;
-    let result = content;
     for (const [rule, lineSet] of fixesByRule) {
         if (!fixableRules.has(rule))
             continue;
@@ -339,30 +343,38 @@ function applyFixes(issues, content, filepath) {
             const idx = line - 1;
             if (idx < 0 || idx >= lines.length)
                 continue;
-            const lineContent = result.split('\n')[idx];
+            const lineContent = lines[idx];
             switch (rule) {
                 case 'redundant_quotes': {
                     const fixed = lineContent.replace(/''(\S)/g, "'$1");
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'double_not': {
                     const fixed = lineContent.replace(/\(not\s+\(not\s+/g, '(not ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'redundant_nil_else': {
                     const fixed = lineContent.replace(/\s+nil\s*\)$/, ')');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'single_arg_and_or': {
                     const m = lineContent.match(/\((and|or)\s+([^)\s]+)\s*\)/);
-                    if (m)
-                        result = replaceLine(result, idx, m[2]);
+                    if (m) {
+                        lines[idx] = m[2];
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'redundant_progn': {
@@ -374,16 +386,20 @@ function applyFixes(issues, content, filepath) {
                             const inner = lineContent.slice(proIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforePro + inner + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
                 }
                 case 'redundant_let': {
                     const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'quote_style': {
@@ -395,8 +411,10 @@ function applyFixes(issues, content, filepath) {
                             const quoted = lineContent.slice(qIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforeQ + "'" + quoted + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -410,8 +428,10 @@ function applyFixes(issues, content, filepath) {
                             const inner = lineContent.slice(pIdx + 7, close);
                             const rest = lineContent.slice(close + 1);
                             const fixed = beforeP + inner + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -436,18 +456,18 @@ function applyFixes(issues, content, filepath) {
                         if (thenForm && elseForm) {
                             const rest = lineContent.slice(ifClose + 1);
                             const fixed = indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
-                            if (fixed !== lineContent)
-                                result = replaceLine(result, idx, fixed);
+                            if (fixed !== lineContent) {
+                                lines[idx] = fixed;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
                 }
                 case 'redundant_setq': {
-                    const allLines = result.split('\n');
-                    const trimmed = allLines[idx].trim();
+                    const trimmed = lines[idx].trim();
                     if (/^\(setq\s+(\S+)\s+\1\s*\)$/.test(trimmed)) {
-                        allLines.splice(idx, 1);
-                        result = allLines.join('\n');
+                        lines.splice(idx, 1);
                     }
                     break;
                 }
@@ -456,12 +476,15 @@ function applyFixes(issues, content, filepath) {
                     if (fixed !== lineContent) {
                         const merged = lineContent.replace(/^\(\s*setq\s+/, '(setq ');
                         if (merged.includes('setq') && !merged.match(/\)\(/)) {
-                            result = replaceLine(result, idx, merged);
+                            lines[idx] = merged;
+                            fixedLines.add(idx);
                         }
                         else {
                             const simplified = lineContent.replace(/\)\(setq\s+/g, '\n');
-                            if (simplified !== lineContent)
-                                result = replaceLine(result, idx, simplified);
+                            if (simplified !== lineContent) {
+                                lines[idx] = simplified;
+                                fixedLines.add(idx);
+                            }
                         }
                     }
                     break;
@@ -475,8 +498,10 @@ function applyFixes(issues, content, filepath) {
                             const listMatch = inner.match(/^\(list\s+(.*)\)\s*$/);
                             if (listMatch) {
                                 const fixed = lineContent.slice(0, aIdx) + '(cons ' + listMatch[1] + ')' + lineContent.slice(close + 1);
-                                if (fixed !== lineContent)
-                                    result = replaceLine(result, idx, fixed);
+                                if (fixed !== lineContent) {
+                                    lines[idx] = fixed;
+                                    fixedLines.add(idx);
+                                }
                             }
                         }
                     }
@@ -484,40 +509,48 @@ function applyFixes(issues, content, filepath) {
                 }
                 case 'nth_usage': {
                     const fixed = lineContent.replace(/\(nth\s+0\s+/g, '(car ');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'setq_single_arg': {
-                    const allLines = result.split('\n');
-                    if (/^\s*\(setq\s+\S+\s*\)\s*$/.test(allLines[idx])) {
-                        allLines.splice(idx, 1);
-                        result = allLines.join('\n');
+                    if (/^\s*\(setq\s+\S+\s*\)\s*$/.test(lines[idx])) {
+                        lines.splice(idx, 1);
                     }
                     break;
                 }
                 case 'extra_parens': {
                     const fixed = lineContent.replace(/\){2,}/g, ')');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'empty_branch': {
                     const fixed = lineContent.replace(/\(if\s+\S+\s*\)/g, m => m.slice(0, -1) + ' nil)');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'comment_style': {
                     const fixed = lineContent.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'eq_usage': {
                     const fixed = lineContent.replace(/\(eq\s+(\S+)\s+(\d+)\s*\)/g, '(= $1 $2)');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'cond_simplify': {
@@ -538,8 +571,10 @@ function applyFixes(issues, content, filepath) {
                                         const bodyExpr = branchContent.slice(space).trim();
                                         const rest = lineContent.slice(condEnd + 1);
                                         const fixed = indent + '(if ' + testExpr + ' ' + bodyExpr + ')' + rest;
-                                        if (fixed !== lineContent)
-                                            result = replaceLine(result, idx, fixed);
+                                        if (fixed !== lineContent) {
+                                            lines[idx] = fixed;
+                                            fixedLines.add(idx);
+                                        }
                                     }
                                 }
                             }
@@ -549,34 +584,31 @@ function applyFixes(issues, content, filepath) {
                 }
                 case 'self_compare': {
                     const fixed = lineContent.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
                 case 'while_constant': {
-                    const allLines = result.split('\n');
-                    const trimmed = allLines[idx].trim();
+                    const trimmed = lines[idx].trim();
                     const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
                     if (nilMatch) {
-                        allLines[idx] = allLines[idx].replace(trimmed, 'nil');
-                        result = allLines.join('\n');
+                        lines[idx] = lines[idx].replace(trimmed, 'nil');
                     }
                     break;
                 }
                 case 'redundant_list': {
                     const fixed = lineContent.replace(/\(\s*list\s*\)/g, 'nil');
-                    if (fixed !== lineContent)
-                        result = replaceLine(result, idx, fixed);
+                    if (fixed !== lineContent) {
+                        lines[idx] = fixed;
+                        fixedLines.add(idx);
+                    }
                     break;
                 }
             }
         }
     }
-    return result;
-}
-function replaceLine(content, lineIdx, newLine) {
-    const lines = content.split('\n');
-    lines[lineIdx] = newLine;
     return lines.join('\n');
 }
 function parseIgnoreFile(rootDir) {
@@ -593,23 +625,51 @@ const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
     let content = fs.readFileSync(filepath, 'utf-8');
-    const wsFixed = content
-        .split('\n')
-        .map(l => l.replace(/[ \t]+$/, ''))
-        .join('\n');
-    if (wsFixed !== content) {
-        content = wsFixed;
-        fixes.push('trailing_whitespace');
-    }
+    // 1. Remove BOM
     if (content.charCodeAt(0) === UTF8_BOM) {
         content = content.slice(1);
         fixes.push('encoding (BOM)');
     }
+    // 2. Single line pass: trailing whitespace + empty comment lines
+    const origLines = content.split('\n');
+    let wsChanged = false;
+    let ecChanged = false;
+    const processed = origLines.map(l => {
+        const stripped = l.replace(/[ \t]+$/, '');
+        if (stripped !== l)
+            wsChanged = true;
+        if (/^\s*;\s*$/.test(stripped)) {
+            ecChanged = true;
+            return '';
+        }
+        return stripped;
+    });
+    if (wsChanged)
+        fixes.push('trailing_whitespace');
+    if (ecChanged)
+        fixes.push('empty_comment');
+    if (wsChanged || ecChanged)
+        content = processed.join('\n');
+    // 3. Count parens (string/comment aware), fix trailing excess
     let openCount = 0;
     let closeCount = 0;
-    let fixContent = content;
-    for (let i = 0; i < fixContent.length; i++) {
-        const ch = fixContent[i];
+    let inStr = false;
+    for (let i = 0; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === '"') {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr) {
+            if (ch === '\\')
+                i++;
+            continue;
+        }
+        if (ch === ';') {
+            const nl = content.indexOf('\n', i);
+            i = nl !== -1 ? nl : content.length;
+            continue;
+        }
         if (ch === '(')
             openCount++;
         else if (ch === ')')
@@ -617,29 +677,17 @@ function fixFile(filepath) {
     }
     if (closeCount > openCount) {
         let excess = closeCount - openCount;
-        while (excess > 0 && fixContent.endsWith(')')) {
-            fixContent = fixContent.slice(0, -1);
+        let fixed = content;
+        while (excess > 0 && fixed.endsWith(')')) {
+            fixed = fixed.slice(0, -1);
             excess--;
         }
-        fixContent = fixContent.replace(/\n[ \t]*$/, '');
-        if (fixContent !== content) {
-            content = fixContent;
+        fixed = fixed.replace(/\n[ \t]*$/, '');
+        if (fixed !== content) {
+            content = fixed;
             fixes.push('trailing_paren');
         }
     }
-    const lines = content.split('\n');
-    let changed = false;
-    const fixedLines = lines.map(l => {
-        if (/^\s*;\s*$/.test(l)) {
-            changed = true;
-            return '';
-        }
-        return l;
-    });
-    if (changed) {
-        content = fixedLines.join('\n');
-        fixes.push('empty_comment');
-    }
     if (fixes.length > 0) {
         fs.writeFileSync(filepath, content, 'utf-8');
     }

package/dist/stub-packages.json

@@ -0,0 +1,41 @@
+((AUTOLISP ())
+ (@ (COMMON-LISP AUTOLISP))
+ (C ())
+ (JSON ())
+ (SIDEBAR ())
+ (FUN ())
+ (DCL ())
+ (BASE ())
+ (STRING ())
+ (BLOCK ())
+ (ENTITY ())
+ (LAYER ())
+ (LAYOUT ())
+ (CURVE ())
+ (LIST ())
+ (M ())
+ (P ())
+ (UI ())
+ (SYS ())
+ (EXCEL ())
+ (WORD ())
+ (RE ())
+ (VECTRA ())
+ (DOS ())
+ (AT-PM ())
+ (QRENCODE ())
+ (NETWORK ())
+ (PKGMAN ())
+ (DATETIME ())
+ (DICT ())
+ (@NLP ())
+ (AT-SIDEBAR ())
+ (S ())
+ (VL ())
+ (VLR ())
+ (VLAX ())
+ (THEME ())
+ (AJAX ())
+ (ATLISP ())
+ (LOG ())
+ (ATLISP-CORE ()))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",
@@ -37,7 +37,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@atlisp/parser": "^0.1.2"
+    "@atlisp/parser": "^0.1.3"
   },
   "devDependencies": {
     "@types/jest": "^29",