@atlisp/lint 0.1.5 → 0.1.6

package/dist/rules.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULES = void 0;
+exports.generateRulesMarkdown = generateRulesMarkdown;
+exports.RULES = [
+    {
+        name: 'append_single',
+        defaultSeverity: 'warn',
+        description: '检测 (append (list ...)) 推荐使用 cons',
+        category: '风格',
+    },
+    {
+        name: 'arg_count',
+        defaultSeverity: 'warn',
+        description: '检查函数调用参数数量是否与定义匹配',
+        category: '最佳实践',
+    },
+    {
+        name: 'assoc_without_cdr',
+        defaultSeverity: 'warn',
+        description: '检测 assoc 结果未用 cdr 提取值',
+        category: '正确性',
+    },
+    {
+        name: 'bare_function_names',
+        defaultSeverity: 'off',
+        description: '检测缺少命名空间前缀的 defun',
+        category: '风格',
+    },
+    { name: 'cl_syntax', defaultSeverity: 'warn', description: '检测 Common Lisp 特有语法（如 &key）', category: '语法' },
+    {
+        name: 'command_shell',
+        defaultSeverity: 'error',
+        description: '检测 command shell 调用（命令注入风险）',
+        category: '安全',
+    },
+    { name: 'comment_style', defaultSeverity: 'warn', description: '检测 ; 后缺少空格的注释', category: '风格' },
+    { name: 'commented_code', defaultSeverity: 'warn', description: '检测被注释掉的代码', category: '风格' },
+    { name: 'cond_simplify', defaultSeverity: 'warn', description: '检测可简化为 if 的单分支 cond', category: '风格' },
+    {
+        name: 'constant_condition',
+        defaultSeverity: 'warn',
+        description: '检测 if/while/cond 中使用的常量条件',
+        category: '风格',
+    },
+    { name: 'cond_duplicate', defaultSeverity: 'warn', description: '检测 cond 中的重复条件', category: '正确性' },
+    {
+        name: 'dangling_defun',
+        defaultSeverity: 'warn',
+        description: '检测定义了但从未被调用的函数（跨文件）',
+        category: '正确性',
+    },
+    { name: 'duplicate_defun', defaultSeverity: 'warn', description: '检测多次定义的函数名', category: '正确性' },
+    {
+        name: 'double_not',
+        defaultSeverity: 'warn',
+        description: '检测双重 (not (not ...)) 可简化为单个 not',
+        category: '风格',
+    },
+    { name: 'dynamic_doc', defaultSeverity: 'warn', description: '检测 C: 命令是否缺少 (princ)', category: '最佳实践' },
+    { name: 'empty_branch', defaultSeverity: 'warn', description: '检测 if/cond 中为空的分支', category: '风格' },
+    {
+        name: 'empty_catch',
+        defaultSeverity: 'warn',
+        description: '检测未检查结果的 vl-catch-all-apply',
+        category: '最佳实践',
+    },
+    { name: 'empty_comment', defaultSeverity: 'warn', description: '检测空注释行（只有分号没有内容）', category: '风格' },
+    { name: 'encoding', defaultSeverity: 'error', description: '检查 UTF-8 BOM 和非 UTF-8 编码', category: '编码' },
+    { name: 'eq_usage', defaultSeverity: 'warn', description: '检测 eq 与数字比较', category: '最佳实践' },
+    {
+        name: 'error_handling',
+        defaultSeverity: 'warn',
+        description: '检测使用 command 但缺少 *error* 处理',
+        category: '最佳实践',
+    },
+    { name: 'extra_parens', defaultSeverity: 'warn', description: '检测可疑的连续右括号', category: '语法' },
+    {
+        name: 'function_complexity',
+        defaultSeverity: 'warn',
+        description: '检查函数行数和嵌套深度是否超限',
+        category: '复杂度',
+    },
+    { name: 'function_order', defaultSeverity: 'off', description: '检测函数定义在使用之后', category: '风格' },
+    {
+        name: 'identical_branches',
+        defaultSeverity: 'warn',
+        description: '检测 if 中 then 和 else 分支完全相同',
+        category: '正确性',
+    },
+    { name: 'global_naming', defaultSeverity: 'warn', description: '检测全局变量是否使用 *...* 命名', category: '风格' },
+    {
+        name: 'lambda_syntax',
+        defaultSeverity: 'warn',
+        description: '检测 (function (lambda ...)) 建议使用缩写',
+        category: '风格',
+    },
+    { name: 'line_length', defaultSeverity: 'warn', description: '检查行长度是否超过限制', category: '风格' },
+    { name: 'long_function_call', defaultSeverity: 'warn', description: '检测单行参数过多的函数调用', category: '风格' },
+    {
+        name: 'loop_optimization',
+        defaultSeverity: 'off',
+        description: '检测可优化的 while/assoc 循环',
+        category: '最佳实践',
+    },
+    { name: 'magic_number', defaultSeverity: 'off', description: '检测硬编码的魔法数字', category: '风格' },
+    {
+        name: 'misplaced_else',
+        defaultSeverity: 'warn',
+        description: '检测 (if (not ...) ...) 建议交换分支',
+        category: '风格',
+    },
+    { name: 'missing_doc', defaultSeverity: 'warn', description: '检测缺少注释说明的函数', category: '风格' },
+    { name: 'missing_export', defaultSeverity: 'warn', description: '检测函数未注册到 @::*modules*', category: '架构' },
+    { name: 'mixed_indent', defaultSeverity: 'warn', description: '检测缩进中混用 tab 和空格', category: '风格' },
+    {
+        name: 'module_registration',
+        defaultSeverity: 'off',
+        description: '检测模块文件是否注册到 *modules*',
+        category: '架构',
+    },
+    { name: 'multiple_setq', defaultSeverity: 'warn', description: '检测多个连续 setq 可以合并', category: '风格' },
+    {
+        name: 'namespace_header',
+        defaultSeverity: 'off',
+        description: '检测文件是否包含 (in-package ...) 头',
+        category: '架构',
+    },
+    { name: 'no_return', defaultSeverity: 'warn', description: '检测没有返回值的函数', category: '最佳实践' },
+    { name: 'nth_usage', defaultSeverity: 'warn', description: '检测 (nth 0 ...) 推荐使用 car', category: '风格' },
+    {
+        name: 'open_without_close',
+        defaultSeverity: 'warn',
+        description: '检测 open/close 数量不匹配（资源泄露）',
+        category: '最佳实践',
+    },
+    { name: 'parameter_naming', defaultSeverity: 'warn', description: '检查参数名是否首字母大写', category: '风格' },
+    { name: 'parens', defaultSeverity: 'error', description: '检查括号是否匹配（考虑字符串和注释）', category: '语法' },
+    {
+        name: 'quit_exit',
+        defaultSeverity: 'error',
+        description: '检测 quit/exit 调用（会终止 CAD 进程）',
+        category: '安全',
+    },
+    { name: 'quote_style', defaultSeverity: 'warn', description: '检测 (quote ...) 建议使用缩写', category: '风格' },
+    {
+        name: 'quote_vs_function',
+        defaultSeverity: 'warn',
+        description: '检测在 mapcar/apply 中使用引用 lambda 而非 function',
+        category: '风格',
+    },
+    {
+        name: 'recursive_call',
+        defaultSeverity: 'warn',
+        description: '检测函数调用自身（可能无限递归）',
+        category: '正确性',
+    },
+    { name: 'redundant_cond', defaultSeverity: 'warn', description: '检测单子句 cond 或末尾 T 子句', category: '风格' },
+    { name: 'redundant_if', defaultSeverity: 'warn', description: '检测 if/when 分支中冗余 progn', category: '风格' },
+    { name: 'redundant_let', defaultSeverity: 'warn', description: '检测无绑定的 let 建议改用 progn', category: '风格' },
+    { name: 'redundant_nil_else', defaultSeverity: 'warn', description: '检测 if 中冗余的 nil 分支', category: '风格' },
+    { name: 'redundant_progn', defaultSeverity: 'warn', description: '检测分支中多余的 progn', category: '风格' },
+    { name: 'redundant_quotes', defaultSeverity: 'warn', description: "检测冗余双引号（如 ''x）", category: '风格' },
+    { name: 'redundant_setq', defaultSeverity: 'warn', description: '检测 setq 变量赋值为自身', category: '风格' },
+    {
+        name: 'self_compare',
+        defaultSeverity: 'warn',
+        description: '检测自比较表达式（恒为 T 或 nil）',
+        category: '正确性',
+    },
+    { name: 'setq_single_arg', defaultSeverity: 'warn', description: '检测 setq 只有变量名缺少值', category: '正确性' },
+    { name: 'setq_multiple', defaultSeverity: 'warn', description: '检测多个连续 setq 可以合并', category: '风格' },
+    { name: 'shadow_builtin', defaultSeverity: 'warn', description: '检测覆盖内置函数的 defun', category: '最佳实践' },
+    { name: 'single_arg_and_or', defaultSeverity: 'warn', description: '检测单参数 and/or 建议简化', category: '风格' },
+    { name: 'startapp', defaultSeverity: 'warn', description: '检测 startapp 调用（启动外部程序）', category: '安全' },
+    {
+        name: 'strcat_usage',
+        defaultSeverity: 'warn',
+        description: '检测是否使用 + 而非 strcat 拼接字符串',
+        category: '最佳实践',
+    },
+    {
+        name: 'token_in_url',
+        defaultSeverity: 'warn',
+        description: '检测字符串中的 token= 参数（凭据泄露）',
+        category: '安全',
+    },
+    { name: 'trailing_paren', defaultSeverity: 'warn', description: '检测多余闭合括号', category: '语法' },
+    { name: 'trailing_whitespace', defaultSeverity: 'warn', description: '检测行尾多余空格', category: '风格' },
+    { name: 'type_check', defaultSeverity: 'off', description: '检测 getvar 结果未做类型检查', category: '最佳实践' },
+    {
+        name: 'unused_let_binding',
+        defaultSeverity: 'warn',
+        description: '检测 let 绑定但未使用的变量',
+        category: '最佳实践',
+    },
+    {
+        name: 'unused_local_fun',
+        defaultSeverity: 'warn',
+        description: '检测 defun / 后定义的局部函数/变量未使用',
+        category: '最佳实践',
+    },
+    { name: 'unused_package_dep', defaultSeverity: 'warn', description: '检测导入的包从未被引用', category: '架构' },
+    { name: 'unused_parameter', defaultSeverity: 'warn', description: '检测函数中未使用的参数', category: '最佳实践' },
+    { name: 'unused_variable', defaultSeverity: 'warn', description: '检测被赋值但未使用的变量', category: '最佳实践' },
+    {
+        name: 'variable_shadow',
+        defaultSeverity: 'warn',
+        description: '检测 setq 覆盖了 let 绑定的同名变量',
+        category: '最佳实践',
+    },
+    { name: 'while_constant', defaultSeverity: 'warn', description: '检测 while 使用常量条件', category: '正确性' },
+    {
+        name: 'vl_registry_write',
+        defaultSeverity: 'warn',
+        description: '检测 vl-registry-write（修改注册表）',
+        category: '安全',
+    },
+    {
+        name: 'vlax_without_loading',
+        defaultSeverity: 'off',
+        description: '检测 vlax-* 使用前未调用 vl-load-com',
+        category: '最佳实践',
+    },
+];
+function generateRulesMarkdown() {
+    const lines = [
+        '# @atlisp/lint Rules',
+        '',
+        '| Rule | Default | Category | Description |',
+        '|------|---------|----------|-------------|',
+    ];
+    for (const r of exports.RULES) {
+        lines.push(`| \`${r.name}\` | ${r.defaultSeverity} | ${r.category} | ${r.description} |`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=rules.js.map

package/dist/runner.d.ts

@@ -4,5 +4,7 @@ export declare function runChecks(content: string, file: string, config: LintCon
 export declare function runChecksWithVisitor(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 function applyFixes(issues: Issue[], content: string, filepath: string): string;
+export declare function parseIgnoreFile(rootDir: string): string[];
 export declare function fixFile(filepath: string): string[];
 //# sourceMappingURL=runner.d.ts.map

package/dist/runner.js

@@ -37,6 +37,8 @@ exports.runChecks = runChecks;
 exports.runChecksWithVisitor = runChecksWithVisitor;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
+exports.applyFixes = applyFixes;
+exports.parseIgnoreFile = parseIgnoreFile;
 exports.fixFile = fixFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -80,6 +82,35 @@ const misplaced_else_1 = require("./checks/misplaced-else");
 const quote_vs_function_1 = require("./checks/quote-vs-function");
 const commented_code_1 = require("./checks/commented-code");
 const double_not_1 = require("./checks/double-not");
+const setq_single_arg_1 = require("./checks/setq-single-arg");
+const assoc_without_cdr_1 = require("./checks/assoc-without-cdr");
+const identical_branches_1 = require("./checks/identical-branches");
+const while_constant_1 = require("./checks/while-constant");
+const cond_duplicate_1 = require("./checks/cond-duplicate");
+const error_handling_1 = require("./checks/error-handling");
+const global_naming_1 = require("./checks/global-naming");
+const extra_parens_1 = require("./checks/extra-parens");
+const arg_count_1 = require("./checks/arg-count");
+const strcat_usage_1 = require("./checks/strcat-usage");
+const cond_simplify_1 = require("./checks/cond-simplify");
+const quote_style_1 = require("./checks/quote-style");
+const eq_usage_1 = require("./checks/eq-usage");
+const lambda_syntax_1 = require("./checks/lambda-syntax");
+const comment_style_1 = require("./checks/comment-style");
+const empty_catch_1 = require("./checks/empty-catch");
+const nth_usage_1 = require("./checks/nth-usage");
+const append_single_1 = require("./checks/append-single");
+const setq_multiple_1 = require("./checks/setq-multiple");
+const function_order_1 = require("./checks/function-order");
+const magic_number_1 = require("./checks/magic-number");
+const mixed_indent_1 = require("./checks/mixed-indent");
+const long_function_call_1 = require("./checks/long-function-call");
+const no_return_1 = require("./checks/no-return");
+const shadow_builtin_1 = require("./checks/shadow-builtin");
+const dynamic_doc_1 = require("./checks/dynamic-doc");
+const loop_optimization_1 = require("./checks/loop-optimization");
+const type_check_1 = require("./checks/type-check");
+const redundant_if_1 = require("./checks/redundant-if");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
@@ -87,8 +118,44 @@ const parser_1 = require("@atlisp/parser");
 function runChecks(content, file, config) {
     const issues = [];
     const disableMap = (0, disable_1.parseDisableComments)(content);
-    // Parse AST once for all checks that need it
-    const ast = (0, parser_1.parseAst)(content);
+    // Deferred AST parsing: only parse if any AST-based checks are enabled
+    const astRules = new Set([
+        'quit_exit',
+        'open_without_close',
+        'function_complexity',
+        'parameter_naming',
+        'unused_variable',
+        'unused_parameter',
+        'constant_condition',
+        'redundant_progn',
+        'empty_branch',
+        'unused_let_binding',
+        'recursive_call',
+        'variable_shadow',
+        'redundant_cond',
+        'unused_local_fun',
+        'multiple_setq',
+        'redundant_quotes',
+        'redundant_setq',
+        'redundant_nil_else',
+        'single_arg_and_or',
+        'redundant_let',
+        'self_compare',
+        'misplaced_else',
+        'quote_vs_function',
+        'double_not',
+        'setq_single_arg',
+        'assoc_without_cdr',
+        'identical_branches',
+        'while_constant',
+        'cond_duplicate',
+    ]);
+    const checks = config.checks;
+    const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
+    let ast;
+    if (needsAst) {
+        ast = (0, parser_1.parseAst)(content);
+    }
     function addIfEnabled(rule, fn) {
         const severity = config.checks[rule];
         if (severity === 'off')
@@ -138,6 +205,35 @@ function runChecks(content, file, config) {
     addIfEnabled('quote_vs_function', () => (0, quote_vs_function_1.checkQuoteVsFunctionAst)(ast, file));
     addIfEnabled('commented_code', () => (0, commented_code_1.checkCommentedCode)(content, file));
     addIfEnabled('double_not', () => (0, double_not_1.checkDoubleNotAst)(ast, file));
+    addIfEnabled('setq_single_arg', () => (0, setq_single_arg_1.checkSetqSingleArgAst)(ast, file));
+    addIfEnabled('assoc_without_cdr', () => (0, assoc_without_cdr_1.checkAssocWithoutCdrAst)(ast, file));
+    addIfEnabled('identical_branches', () => (0, identical_branches_1.checkIdenticalBranchesAst)(ast, file));
+    addIfEnabled('while_constant', () => (0, while_constant_1.checkWhileConstantAst)(ast, file));
+    addIfEnabled('cond_duplicate', () => (0, cond_duplicate_1.checkCondDuplicateAst)(ast, file));
+    addIfEnabled('error_handling', () => (0, error_handling_1.checkErrorHandling)(content, file));
+    addIfEnabled('global_naming', () => (0, global_naming_1.checkGlobalNaming)(content, file));
+    addIfEnabled('extra_parens', () => (0, extra_parens_1.checkExtraParens)(content, file));
+    addIfEnabled('arg_count', () => (0, arg_count_1.checkArgCount)(content, file));
+    addIfEnabled('strcat_usage', () => (0, strcat_usage_1.checkStrcatUsage)(content, file));
+    addIfEnabled('cond_simplify', () => (0, cond_simplify_1.checkCondSimplify)(content, file));
+    addIfEnabled('quote_style', () => (0, quote_style_1.checkQuoteStyle)(content, file));
+    addIfEnabled('eq_usage', () => (0, eq_usage_1.checkEqUsage)(content, file));
+    addIfEnabled('lambda_syntax', () => (0, lambda_syntax_1.checkLambdaSyntax)(content, file));
+    addIfEnabled('comment_style', () => (0, comment_style_1.checkCommentStyle)(content, file));
+    addIfEnabled('empty_catch', () => (0, empty_catch_1.checkEmptyCatch)(content, file));
+    addIfEnabled('nth_usage', () => (0, nth_usage_1.checkNthUsage)(content, file));
+    addIfEnabled('append_single', () => (0, append_single_1.checkAppendSingle)(content, file));
+    addIfEnabled('setq_multiple', () => (0, setq_multiple_1.checkSetqMultiple)(content, file));
+    addIfEnabled('function_order', () => (0, function_order_1.checkFunctionOrder)(content, file));
+    addIfEnabled('magic_number', () => (0, magic_number_1.checkMagicNumber)(content, file));
+    addIfEnabled('mixed_indent', () => (0, mixed_indent_1.checkMixedIndent)(content, file));
+    addIfEnabled('long_function_call', () => (0, long_function_call_1.checkLongFunctionCall)(content, file, 6));
+    addIfEnabled('no_return', () => (0, no_return_1.checkNoReturn)(content, file));
+    addIfEnabled('shadow_builtin', () => (0, shadow_builtin_1.checkShadowBuiltin)(content, file));
+    addIfEnabled('dynamic_doc', () => (0, dynamic_doc_1.checkDynamicDoc)(content, file));
+    addIfEnabled('loop_optimization', () => (0, loop_optimization_1.checkLoopOptimization)(content, file));
+    addIfEnabled('type_check', () => (0, type_check_1.checkTypeCheck)(content, file));
+    addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
     return issues;
 }
 /** Single-pass visitor-based runChecks using AstVisitor */
@@ -156,7 +252,7 @@ function runChecksWithVisitor(content, file, config) {
     }
     // Register all AST-based checks as visitor handlers
     if (checks['redundant_quotes'] !== 'off') {
-        visitor.on('quote', (node) => {
+        visitor.on('quote', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -169,7 +265,7 @@ function runChecksWithVisitor(content, file, config) {
         });
     }
     if (checks['double_not'] !== 'off') {
-        visitor.on('not', (node) => {
+        visitor.on('not', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -182,7 +278,7 @@ function runChecksWithVisitor(content, file, config) {
         });
     }
     if (checks['misplaced_else'] !== 'off') {
-        visitor.on('if', (node) => {
+        visitor.on('if', node => {
             if (node.children && node.children.length === 4) {
                 const cond = node.children[1];
                 if (cond.type === 'list' &&
@@ -209,7 +305,7 @@ function runChecksWithVisitor(content, file, config) {
             'vl-some',
             'vl-every',
         ]);
-        visitor.on('quote', (node) => {
+        visitor.on('quote', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -258,7 +354,7 @@ function lintFiles(files, config, rootDir) {
 }
 function lintFilesParallel(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         const allIssues = [];
         let completed = 0;
         const maxWorkers = Math.min(os.cpus().length, files.length);
@@ -280,7 +376,7 @@ function lintFilesParallel(files, config, rootDir) {
                 if (completed >= files.length)
                     resolve(allIssues);
             });
-            worker.on('error', (err) => {
+            worker.on('error', err => {
                 allIssues.push({
                     file: relPath,
                     line: 1,
@@ -294,7 +390,7 @@ function lintFilesParallel(files, config, rootDir) {
                 if (completed >= files.length)
                     resolve(allIssues);
             });
-            worker.on('exit', (code) => {
+            worker.on('exit', code => {
                 if (code !== 0) {
                     allIssues.push({
                         file: relPath,
@@ -317,6 +413,97 @@ function lintFilesParallel(files, config, rootDir) {
             resolve([]);
     });
 }
+function applyFixes(issues, content, filepath) {
+    const lines = content.split('\n');
+    const fixesByRule = new Map();
+    for (const iss of issues) {
+        if (iss.file !== filepath)
+            continue;
+        const set = fixesByRule.get(iss.rule) || new Set();
+        set.add(iss.line);
+        fixesByRule.set(iss.rule, set);
+    }
+    // Apply fixes from higher line numbers first to preserve offsets
+    const fixableRules = new Set([
+        'redundant_quotes',
+        'double_not',
+        'redundant_nil_else',
+        'single_arg_and_or',
+        'redundant_setq',
+    ]);
+    let result = content;
+    for (const [rule, lineSet] of fixesByRule) {
+        if (!fixableRules.has(rule))
+            continue;
+        const sortedLines = Array.from(lineSet).sort((a, b) => b - a);
+        for (const line of sortedLines) {
+            const idx = line - 1;
+            if (idx < 0 || idx >= lines.length)
+                continue;
+            const lineContent = result.split('\n')[idx];
+            switch (rule) {
+                case 'redundant_quotes': {
+                    // Replace ''x with 'x on this line
+                    const fixed = lineContent.replace(/''(\S)/g, "'$1");
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'double_not': {
+                    // Replace (not (not ...)) with (not ...)
+                    const fixed = lineContent.replace(/\(not\s+\(not\s+/g, '(not ');
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'redundant_nil_else': {
+                    // Replace (if ... nil) with (if ...)
+                    const fixed = lineContent.replace(/\s+nil\s*\)$/, ')');
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'single_arg_and_or': {
+                    // Replace (and x) with x, (or x) with x
+                    const m = lineContent.match(/\((and|or)\s+([^)\s]+)\s*\)/);
+                    if (m) {
+                        result = replaceLine(result, idx, m[2]);
+                    }
+                    break;
+                }
+                case 'redundant_setq': {
+                    // Remove (setq x x) lines
+                    const allLines = result.split('\n');
+                    const trimmed = allLines[idx].trim();
+                    if (/^\(setq\s+(\S+)\s+\1\s*\)$/.test(trimmed)) {
+                        allLines.splice(idx, 1);
+                        result = allLines.join('\n');
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+function replaceLine(content, lineIdx, newLine) {
+    const lines = content.split('\n');
+    lines[lineIdx] = newLine;
+    return lines.join('\n');
+}
+function parseIgnoreFile(rootDir) {
+    const ignoreFile = path.join(rootDir, '.atlisp-lint-ignore');
+    if (!fs.existsSync(ignoreFile))
+        return [];
+    const content = fs.readFileSync(ignoreFile, 'utf-8');
+    return content
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.length > 0 && !l.startsWith('#'));
+}
 const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
@@ -324,7 +511,7 @@ function fixFile(filepath) {
     // Fix trailing whitespace
     const wsFixed = content
         .split('\n')
-        .map((l) => l.replace(/[ \t]+$/, ''))
+        .map(l => l.replace(/[ \t]+$/, ''))
         .join('\n');
     if (wsFixed !== content) {
         content = wsFixed;
@@ -362,7 +549,7 @@ function fixFile(filepath) {
     // Fix empty comments: remove lines that are only ';' with optional whitespace
     const lines = content.split('\n');
     let changed = false;
-    const fixedLines = lines.map((l) => {
+    const fixedLines = lines.map(l => {
         if (/^\s*;\s*$/.test(l)) {
             changed = true;
             return '';

package/dist/sbcl.js

@@ -72,7 +72,7 @@ function runSbclLint(srcDir, sbclConfig, stubPackagesPath) {
     }
     try {
         // Convert arrays to Lisp-readable format: ("a" "b")
-        const toLispList = (arr) => '(' + arr.map((s) => `"${s}"`).join(' ') + ')';
+        const toLispList = (arr) => '(' + arr.map(s => `"${s}"`).join(' ') + ')';
         const result = (0, child_process_1.execFileSync)(sbcl, [
             '--script',
             scriptPath,

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/dist/types.d.ts

@@ -1,10 +1,15 @@
 export type Severity = 'off' | 'warn' | 'error';
+export interface Fix {
+    range: [number, number];
+    replacement: string;
+}
 export interface Issue {
     file: string;
     line: number;
     severity: Severity;
     rule: string;
     message: string;
+    fix?: Fix;
 }
 export interface CheckConfig {
     severity: Severity;
@@ -61,6 +66,7 @@ export interface LintConfig {
     namespace_header: NamespaceHeaderConfig;
     bare_function_names: BareFunctionNamesConfig;
     sbcl: SbclConfig;
+    preset?: string;
 }
 export interface FormattedResult {
     issues: Issue[];

package/dist/validate.d.ts

@@ -0,0 +1,8 @@
+import { LintConfig } from './types';
+interface ValidationError {
+    path: string;
+    message: string;
+}
+export declare function validateConfig(config: LintConfig): ValidationError[];
+export {};
+//# sourceMappingURL=validate.d.ts.map