@atlisp/lint 0.1.16 → 0.1.19

package/dist/runner.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runChecks = runChecks;
-exports.runChecksWithVisitor = runChecksWithVisitor;
+exports.runChecksWithVisitorWrapper = runChecksWithVisitorWrapper;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
 exports.applyFixes = applyFixes;
@@ -47,46 +47,14 @@ const os = __importStar(require("os"));
 const encoding_1 = require("./checks/encoding");
 const parens_1 = require("./checks/parens");
 const cl_syntax_1 = require("./checks/cl-syntax");
-const dangerous_calls_1 = require("./checks/dangerous-calls");
 const vlax_1 = require("./checks/vlax");
 const token_in_url_1 = require("./checks/token-in-url");
-const open_close_1 = require("./checks/open-close");
 const bare_names_1 = require("./checks/bare-names");
 const module_reg_1 = require("./checks/module-reg");
 const namespace_header_1 = require("./checks/namespace-header");
 const trailing_ws_1 = require("./checks/trailing-ws");
 const line_length_1 = require("./checks/line-length");
-const function_complexity_1 = require("./checks/function-complexity");
-const parameter_naming_1 = require("./checks/parameter-naming");
-const unused_variable_1 = require("./checks/unused-variable");
 const missing_doc_1 = require("./checks/missing-doc");
-const unused_param_1 = require("./checks/unused-param");
-const constant_condition_1 = require("./checks/constant-condition");
-const redundant_progn_1 = require("./checks/redundant-progn");
-const empty_branch_1 = require("./checks/empty-branch");
-const unused_let_1 = require("./checks/unused-let");
-const recursive_call_1 = require("./checks/recursive-call");
-const variable_shadow_1 = require("./checks/variable-shadow");
-const redundant_cond_1 = require("./checks/redundant-cond");
-const unused_local_fun_1 = require("./checks/unused-local-fun");
-const multiple_setq_1 = require("./checks/multiple-setq");
-const redundant_quotes_1 = require("./checks/redundant-quotes");
-const trailing_paren_1 = require("./checks/trailing-paren");
-const empty_comments_1 = require("./checks/empty-comments");
-const redundant_setq_1 = require("./checks/redundant-setq");
-const redundant_nil_else_1 = require("./checks/redundant-nil-else");
-const single_arg_and_or_1 = require("./checks/single-arg-and-or");
-const redundant_let_1 = require("./checks/redundant-let");
-const self_compare_1 = require("./checks/self-compare");
-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");
@@ -113,53 +81,22 @@ const type_check_1 = require("./checks/type-check");
 const redundant_if_1 = require("./checks/redundant-if");
 const undeclared_setq_1 = require("./checks/undeclared-setq");
 const format_indent_1 = require("./checks/format-indent");
+const trailing_paren_1 = require("./checks/trailing-paren");
+const empty_comments_1 = require("./checks/empty-comments");
+const commented_code_1 = require("./checks/commented-code");
+const unused_catch_result_1 = require("./checks/unused-catch-result");
+const string_concat_loop_1 = require("./checks/string-concat-loop");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
 const parser_1 = require("@atlisp/parser");
+const visitor_runner_1 = require("./visitor-runner");
 function runChecks(content, file, config) {
     const issues = [];
     const disableMap = (0, disable_1.parseDisableComments)(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];
+        const severity = checks[rule];
         if (!severity || severity === 'off')
             return;
         const results = fn();
@@ -169,49 +106,28 @@ function runChecks(content, file, config) {
             }
         }
     }
+    function addIssues(ruleIssues) {
+        for (const r of ruleIssues) {
+            if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
+                issues.push(r);
+            }
+        }
+    }
+    // Non-AST checks (run before AST parsing)
     addIfEnabled('encoding', () => (0, encoding_1.checkEncoding)(content, file));
     addIfEnabled('parens', () => (0, parens_1.checkParens)(content, file));
     addIfEnabled('cl_syntax', () => (0, cl_syntax_1.checkClSyntax)(content, file, config.cl_syntax.keywords));
-    addIfEnabled('quit_exit', () => (0, dangerous_calls_1.checkDangerousCallsAst)(ast, file, config.dangerous_calls));
     addIfEnabled('vlax_without_loading', () => (0, vlax_1.checkVlaxWithoutLoading)(content, file));
     addIfEnabled('token_in_url', () => (0, token_in_url_1.checkTokenInUrl)(content, file));
-    addIfEnabled('open_without_close', () => (0, open_close_1.checkOpenWithoutCloseAst)(ast, file));
     addIfEnabled('bare_function_names', () => (0, bare_names_1.checkBareFunctionNames)(content, file, config.bare_function_names.allowlist, config.bare_function_names.namespace_pattern));
     addIfEnabled('module_registration', () => (0, module_reg_1.checkModuleRegistration)(content, file, file, config.module_registration));
     addIfEnabled('namespace_header', () => (0, namespace_header_1.checkNamespaceHeader)(content, file, config.namespace_header));
     addIfEnabled('line_length', () => (0, line_length_1.checkLineLength)(content, file, config.line_length.max, config.line_length.tab_width));
-    addIfEnabled('function_complexity', () => (0, function_complexity_1.checkFunctionComplexityAst)(ast, file, config.function_complexity.max_lines, config.function_complexity.max_nesting));
-    addIfEnabled('parameter_naming', () => (0, parameter_naming_1.checkParameterNamingAst)(ast, file));
-    addIfEnabled('unused_variable', () => (0, unused_variable_1.checkUnusedVariableAst)(ast, file));
     addIfEnabled('missing_doc', () => (0, missing_doc_1.checkMissingDoc)(content, file));
     addIfEnabled('trailing_whitespace', () => (0, trailing_ws_1.checkTrailingWhitespace)(content, file));
-    addIfEnabled('unused_parameter', () => (0, unused_param_1.checkUnusedParameterAst)(ast, file));
-    addIfEnabled('constant_condition', () => (0, constant_condition_1.checkConstantConditionAst)(ast, file));
-    addIfEnabled('redundant_progn', () => (0, redundant_progn_1.checkRedundantPrognAst)(ast, file));
-    addIfEnabled('empty_branch', () => (0, empty_branch_1.checkEmptyBranchAst)(ast, file));
-    addIfEnabled('unused_let_binding', () => (0, unused_let_1.checkUnusedLetBindingAst)(ast, file));
-    addIfEnabled('recursive_call', () => (0, recursive_call_1.checkRecursiveCallAst)(ast, file));
-    addIfEnabled('variable_shadow', () => (0, variable_shadow_1.checkVariableShadowAst)(ast, file));
-    addIfEnabled('redundant_cond', () => (0, redundant_cond_1.checkRedundantCondAst)(ast, file));
-    addIfEnabled('unused_local_fun', () => (0, unused_local_fun_1.checkUnusedLocalFunAst)(ast, file));
-    addIfEnabled('multiple_setq', () => (0, multiple_setq_1.checkMultipleSetqAst)(ast, file));
-    addIfEnabled('redundant_quotes', () => (0, redundant_quotes_1.checkRedundantQuotesAst)(ast, file));
     addIfEnabled('trailing_paren', () => (0, trailing_paren_1.checkTrailingParen)(content, file));
     addIfEnabled('empty_comment', () => (0, empty_comments_1.checkEmptyComments)(content, file));
-    addIfEnabled('redundant_setq', () => (0, redundant_setq_1.checkRedundantSetqAst)(ast, file));
-    addIfEnabled('redundant_nil_else', () => (0, redundant_nil_else_1.checkRedundantNilElseAst)(ast, file));
-    addIfEnabled('single_arg_and_or', () => (0, single_arg_and_or_1.checkSingleArgAndOrAst)(ast, file));
-    addIfEnabled('redundant_let', () => (0, redundant_let_1.checkRedundantLetAst)(ast, file));
-    addIfEnabled('self_compare', () => (0, self_compare_1.checkSelfCompareAst)(ast, file));
-    addIfEnabled('misplaced_else', () => (0, misplaced_else_1.checkMisplacedElseAst)(ast, file));
-    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));
@@ -238,97 +154,34 @@ function runChecks(content, file, config) {
     addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
     addIfEnabled('undeclared_setq', () => (0, undeclared_setq_1.checkUndeclaredSetq)(content, file));
     addIfEnabled('format_indent', () => (0, format_indent_1.checkFormatIndent)(content, file, config.line_length.tab_width));
+    // New checks
+    addIfEnabled('unused_catch_result', () => (0, unused_catch_result_1.checkUnusedCatchResult)(content, file));
+    addIfEnabled('string_concat_loop', () => (0, string_concat_loop_1.checkStringConcatInLoop)(content, file));
+    // AST-based checks via single-pass visitor
+    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',
+        '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 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);
+    }
     return issues;
 }
-/** Single-pass visitor-based runChecks using AstVisitor */
-function runChecksWithVisitor(content, file, config) {
-    const issues = [];
+function runChecksWithVisitorWrapper(content, file, config) {
     const disableMap = (0, disable_1.parseDisableComments)(content);
     const ast = (0, parser_1.parseAst)(content);
-    const visitor = new parser_1.AstVisitor();
-    const checks = config.checks;
-    function addIssue(rule, line, severity, message) {
-        if (severity === 'off')
-            return;
-        if (!(0, disable_1.isDisabled)(rule, line, disableMap)) {
-            issues.push({ file, line, severity: severity, rule, message });
-        }
-    }
-    // Register all AST-based checks as visitor handlers
-    if (checks['redundant_quotes'] !== 'off') {
-        visitor.on('quote', node => {
-            if (node.children &&
-                node.children.length >= 2 &&
-                node.children[1].type === 'list' &&
-                node.children[1].children &&
-                node.children[1].children.length > 0 &&
-                node.children[1].children[0].type === 'symbol' &&
-                node.children[1].children[0].name === 'quote') {
-                addIssue('redundant_quotes', node.pos.line, checks['redundant_quotes'], (0, locale_1.t)('redundant_quotes'));
-            }
-        });
-    }
-    if (checks['double_not'] !== 'off') {
-        visitor.on('not', node => {
-            if (node.children &&
-                node.children.length >= 2 &&
-                node.children[1].type === 'list' &&
-                node.children[1].children &&
-                node.children[1].children.length > 0 &&
-                node.children[1].children[0].type === 'symbol' &&
-                node.children[1].children[0].name === 'not') {
-                addIssue('double_not', node.pos.line, checks['double_not'], (0, locale_1.t)('double_not'));
-            }
-        });
-    }
-    if (checks['misplaced_else'] !== 'off') {
-        visitor.on('if', node => {
-            if (node.children && node.children.length === 4) {
-                const cond = node.children[1];
-                if (cond.type === 'list' &&
-                    cond.children &&
-                    cond.children.length >= 2 &&
-                    cond.children[0].type === 'symbol' &&
-                    cond.children[0].name === 'not') {
-                    const innerName = cond.children[1].name || '';
-                    addIssue('misplaced_else', node.pos.line, checks['misplaced_else'], (0, locale_1.t)('misplaced_else', innerName));
-                }
-            }
-        });
-    }
-    if (checks['quote_vs_function'] !== 'off') {
-        const higherOrder = new Set([
-            'mapcar',
-            'apply',
-            'lambda',
-            'vl-sort',
-            'vl-sort-i',
-            'vl-remove-if',
-            'vl-remove-if-not',
-            'vl-member-if',
-            'vl-some',
-            'vl-every',
-        ]);
-        visitor.on('quote', node => {
-            if (node.children &&
-                node.children.length >= 2 &&
-                node.children[1].type === 'list' &&
-                node.children[1].children &&
-                node.children[1].children.length > 0 &&
-                node.children[1].children[0].type === 'symbol' &&
-                node.children[1].children[0].name === 'lambda') {
-                const parent = node.parent;
-                if (parent && parent.children && parent.children.length > 0) {
-                    const pName = (parent.children[0].type === 'symbol' && parent.children[0].name) || '';
-                    if (higherOrder.has(pName)) {
-                        addIssue('quote_vs_function', node.pos.line, checks['quote_vs_function'], (0, locale_1.t)('quote_vs_function', pName));
-                    }
-                }
-            }
-        });
-    }
-    visitor.run(ast);
-    return issues;
+    return (0, visitor_runner_1.runChecksWithVisitor)(ast, file, config, disableMap);
 }
 function lintFiles(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
@@ -349,7 +202,6 @@ function lintFiles(files, config, rootDir) {
             });
             continue;
         }
-        // Per-directory config override
         const override = (0, config_1.findOverrides)(filepath);
         const effectiveConfig = override ? (0, config_1.mergeOverrides)(config, override) : config;
         allIssues.push(...runChecks(content, relPath, effectiveConfig));
@@ -417,7 +269,6 @@ function lintFilesParallel(files, config, rootDir) {
             resolve([]);
     });
 }
-/** Find the matching close paren for the first complete form starting at `start` */
 function findMatchingParen(s, start) {
     if (s[start] !== '(')
         return start;
@@ -442,7 +293,6 @@ function findMatchingParen(s, start) {
     }
     return s.length - 1;
 }
-/** Extract the next top-level form(s) from a string starting at `start`. Returns [form, endIdx]. */
 function extractForm(s, start) {
     let i = start;
     while (i < s.length && s[i] === ' ')
@@ -468,18 +318,12 @@ function applyFixes(issues, content, filepath) {
         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',
-        'redundant_progn',
-        'redundant_let',
-        'quote_style',
-        'redundant_if',
-        'misplaced_else',
+        'redundant_quotes', 'double_not', 'redundant_nil_else',
+        'single_arg_and_or', 'redundant_setq', 'redundant_progn',
+        'redundant_let', 'quote_style', 'redundant_if', 'misplaced_else',
+        'setq_multiple', 'append_single', 'nth_usage', 'setq_single_arg',
+        'extra_parens', 'empty_branch',
     ]);
     let result = content;
     for (const [rule, lineSet] of fixesByRule) {
@@ -493,39 +337,30 @@ function applyFixes(issues, content, filepath) {
             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) {
+                    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) {
+                    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) {
+                    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) {
+                    if (m)
                         result = replaceLine(result, idx, m[2]);
-                    }
                     break;
                 }
                 case 'redundant_progn': {
-                    // (progn <single-form>) → <single-form>
                     const proIdx = lineContent.indexOf('(progn ');
                     if (proIdx !== -1) {
                         const beforePro = lineContent.slice(0, proIdx);
@@ -541,14 +376,12 @@ function applyFixes(issues, content, filepath) {
                     break;
                 }
                 case 'redundant_let': {
-                    // (let () body...) → (progn body...)
                     const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
                     if (fixed !== lineContent)
                         result = replaceLine(result, idx, fixed);
                     break;
                 }
                 case 'quote_style': {
-                    // (quote x) → 'x
                     const qIdx = lineContent.indexOf('(quote ');
                     if (qIdx !== -1) {
                         const beforeQ = lineContent.slice(0, qIdx);
@@ -564,7 +397,6 @@ function applyFixes(issues, content, filepath) {
                     break;
                 }
                 case 'redundant_if': {
-                    // (if/when/unless (progn ...) ...) → remove inner progn
                     const pIdx = lineContent.indexOf('(progn ');
                     if (pIdx !== -1) {
                         const beforeP = lineContent.slice(0, pIdx);
@@ -580,7 +412,6 @@ function applyFixes(issues, content, filepath) {
                     break;
                 }
                 case 'misplaced_else': {
-                    // (if (not x) then else) → (if x else then)
                     const ifStart = lineContent.indexOf('(if (not ');
                     if (ifStart !== -1) {
                         const notIdx = lineContent.indexOf('(not ', ifStart);
@@ -607,7 +438,6 @@ function applyFixes(issues, content, filepath) {
                     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)) {
@@ -616,6 +446,63 @@ function applyFixes(issues, content, filepath) {
                     }
                     break;
                 }
+                case 'setq_multiple': {
+                    const fixed = lineContent.replace(/\)\(setq\s+/g, ' ');
+                    if (fixed !== lineContent) {
+                        const merged = lineContent.replace(/^\(\s*setq\s+/, '(setq ');
+                        if (merged.includes('setq') && !merged.match(/\)\(/)) {
+                            result = replaceLine(result, idx, merged);
+                        }
+                        else {
+                            const simplified = lineContent.replace(/\)\(setq\s+/g, '\n');
+                            if (simplified !== lineContent)
+                                result = replaceLine(result, idx, simplified);
+                        }
+                    }
+                    break;
+                }
+                case 'append_single': {
+                    const aIdx = lineContent.indexOf('(append ');
+                    if (aIdx !== -1) {
+                        const close = findMatchingParen(lineContent, aIdx);
+                        if (close > aIdx) {
+                            const inner = lineContent.slice(aIdx + 8, close);
+                            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);
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'nth_usage': {
+                    const fixed = lineContent.replace(/\(nth\s+0\s+/g, '(car ');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    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');
+                    }
+                    break;
+                }
+                case 'extra_parens': {
+                    const fixed = lineContent.replace(/\){2,}/g, ')');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    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);
+                    break;
+                }
             }
         }
     }
@@ -640,7 +527,6 @@ const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
     let content = fs.readFileSync(filepath, 'utf-8');
-    // Fix trailing whitespace
     const wsFixed = content
         .split('\n')
         .map(l => l.replace(/[ \t]+$/, ''))
@@ -649,12 +535,10 @@ function fixFile(filepath) {
         content = wsFixed;
         fixes.push('trailing_whitespace');
     }
-    // Fix UTF-8 BOM
     if (content.charCodeAt(0) === UTF8_BOM) {
         content = content.slice(1);
         fixes.push('encoding (BOM)');
     }
-    // Fix trailing parens: remove excess ')' from end of content
     let openCount = 0;
     let closeCount = 0;
     let fixContent = content;
@@ -671,14 +555,12 @@ function fixFile(filepath) {
             fixContent = fixContent.slice(0, -1);
             excess--;
         }
-        // Also trim trailing whitespace after removing parens
         fixContent = fixContent.replace(/\n[ \t]*$/, '');
         if (fixContent !== content) {
             content = fixContent;
             fixes.push('trailing_paren');
         }
     }
-    // Fix empty comments: remove lines that are only ';' with optional whitespace
     const lines = content.split('\n');
     let changed = false;
     const fixedLines = lines.map(l => {

package/dist/validate.js

@@ -50,7 +50,6 @@ const VALID_RULES = [
     'quote_style',
     'quote_vs_function',
     'recursive_call',
-    'redundant_cond',
     'redundant_if',
     'redundant_let',
     'redundant_nil_else',
@@ -78,6 +77,14 @@ const VALID_RULES = [
     'while_constant',
     'vl_registry_write',
     'vlax_without_loading',
+    'unused_catch_result',
+    'string_concat_loop',
+    'if_without_else',
+    'redundant_list',
+    'entget_in_loop',
+    'promise_handler',
+    'module_cycle',
+    'arg_count_project',
 ];
 const VALID_SEVERITIES = ['off', 'warn', 'error'];
 function validateConfig(config) {

package/dist/visitor-runner.d.ts

@@ -0,0 +1,4 @@
+import { Issue, LintConfig } from './types';
+import { AstNode } from '@atlisp/parser';
+export declare function runChecksWithVisitor(ast: AstNode, file: string, config: LintConfig, disableMap: Map<string, Set<number>>): Issue[];
+//# sourceMappingURL=visitor-runner.d.ts.map