@atlisp/lint 0.2.12 → 0.2.13

package/dist/rules.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RULES = void 0;
 exports.generateRulesMarkdown = generateRulesMarkdown;
 exports.generateSchemaHint = generateSchemaHint;
+exports.generateRuleDetail = generateRuleDetail;
 exports.RULES = [
     {
         name: 'append_single',
@@ -281,6 +282,78 @@ exports.RULES = [
         description: '检测 defun 函数名缺少包名前缀',
         category: '风格',
     },
+    {
+        name: 'command_s',
+        defaultSeverity: 'warn',
+        description: '检测 (command ...) 调用，推荐 (command-s ...)',
+        category: '最佳实践',
+    },
+    {
+        name: 'zerop_usage',
+        defaultSeverity: 'info',
+        description: '检测 (= x 0)，推荐 (zerop x)',
+        category: '风格',
+    },
+    {
+        name: 'progn_in_body',
+        defaultSeverity: 'info',
+        description: '检测 while/repeat/foreach 体中冗余 progn',
+        category: '风格',
+    },
+    {
+        name: 'if_progn_both',
+        defaultSeverity: 'info',
+        description: '检测 if 两个分支都使用 progn，推荐 cond',
+        category: '风格',
+    },
+    {
+        name: 'redundant_cond',
+        defaultSeverity: 'info',
+        description: '检测单子句 cond，推荐 if',
+        category: '风格',
+    },
+    {
+        name: 'selection_set_leak',
+        defaultSeverity: 'warn',
+        description: '检测 ssget/ssset 次数不匹配',
+        category: '正确性',
+    },
+    {
+        name: 'empty_branch_cond',
+        defaultSeverity: 'warn',
+        description: '检测 cond 子句没有表达式',
+        category: '正确性',
+    },
+    {
+        name: 'function_reference',
+        defaultSeverity: 'warn',
+        description: '检测函数被引用但从未定义（跨文件）',
+        category: '正确性',
+    },
+    {
+        name: 'progn_in_cond',
+        defaultSeverity: 'info',
+        description: '检测 cond 子句中冗余 progn',
+        category: '风格',
+    },
+    {
+        name: 'redundant_car_cdr',
+        defaultSeverity: 'info',
+        description: '检测 (car (car x)) 等可简化为 (caar x)',
+        category: '风格',
+    },
+    {
+        name: 'equal_nil',
+        defaultSeverity: 'info',
+        description: '检测 (equal x nil) 建议使用 (null x)',
+        category: '风格',
+    },
+    {
+        name: 'redundant_and_or',
+        defaultSeverity: 'info',
+        description: '检测无参数的 (and) 或 (or)——可能是残留代码',
+        category: '风格',
+    },
 ];
 function generateRulesMarkdown() {
     const lines = [
@@ -300,4 +373,16 @@ function generateSchemaHint() {
 
 Total rules: ${exports.RULES.length}`;
 }
+function generateRuleDetail(ruleName) {
+    const rule = exports.RULES.find(r => r.name === ruleName);
+    if (!rule)
+        return `Unknown rule: ${ruleName}. Use --list-rules to see all rules.`;
+    const lines = [
+        `Rule:        ${rule.name}`,
+        `Severity:    ${rule.defaultSeverity}`,
+        `Category:    ${rule.category}`,
+        `Description: ${rule.description}`,
+    ];
+    return lines.join('\n');
+}
 //# sourceMappingURL=rules.js.map

package/dist/runner.d.ts

@@ -1,9 +1,8 @@
 import { Issue, LintConfig } from './types';
 export declare function runChecks(content: string, file: string, config: LintConfig): Issue[];
-export declare function lintFiles(files: string[], config: LintConfig, rootDir: string): Issue[];
+export declare function lintFiles(files: string[], config: LintConfig, rootDir: string, contentCache?: Map<string, string>): Issue[];
 export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
-export declare const FIXABLE_RULES: Set<string>;
-export declare function applyFixes(issues: Issue[], content: string, filepath: string): string;
+export { applyFixesFromProviders as applyFixes, FIXABLE_RULES } from './fixes/index';
 export declare function parseIgnoreFile(rootDir: string): string[];
 export declare function fixFile(filepath: string): string[];
 //# sourceMappingURL=runner.d.ts.map

package/dist/runner.js

@@ -33,11 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIXABLE_RULES = void 0;
+exports.FIXABLE_RULES = exports.applyFixes = void 0;
 exports.runChecks = runChecks;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
-exports.applyFixes = applyFixes;
 exports.parseIgnoreFile = parseIgnoreFile;
 exports.fixFile = fixFile;
 const fs = __importStar(require("fs"));
@@ -110,8 +109,8 @@ function runChecks(content, file, config) {
                 }
             }
         }
-        catch {
-            // Check failed, continue with remaining checks
+        catch (e) {
+            console.warn(`[lint] check "${rule}" failed for ${file}: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
     function addIssues(ruleIssues) {
@@ -198,6 +197,17 @@ function runChecks(content, file, config) {
         'identical_branches',
         'while_constant',
         'cond_duplicate',
+        'command_s',
+        'zerop_usage',
+        'progn_in_body',
+        'if_progn_both',
+        'redundant_cond',
+        'selection_set_leak',
+        'empty_branch_cond',
+        'progn_in_cond',
+        'redundant_car_cdr',
+        'equal_nil',
+        'redundant_and_or',
     ]);
     const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
     if (needsAst) {
@@ -206,35 +216,49 @@ function runChecks(content, file, config) {
             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
+        catch (e) {
+            console.warn(`[lint] AST parse/visitor failed for ${file}: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
     return issues;
 }
-function lintFiles(files, config, rootDir) {
+function lintFiles(files, config, rootDir, contentCache) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
-    for (const filepath of files) {
+    const total = files.length;
+    const showProgress = process.stderr.isTTY && total > 5;
+    for (let fi = 0; fi < total; fi++) {
+        const filepath = files[fi];
         const relPath = path.relative(rootDir, filepath);
+        if (showProgress) {
+            process.stderr.write(`\r[${fi + 1}/${total}] ${relPath}  `);
+        }
         let content;
-        try {
-            content = fs.readFileSync(filepath, 'utf-8');
+        if (contentCache && contentCache.has(filepath)) {
+            content = contentCache.get(filepath);
         }
-        catch {
-            allIssues.push({
-                file: relPath,
-                line: 1,
-                severity: 'error',
-                rule: 'read',
-                message: (0, locale_1.t)('runner.read_error'),
-            });
-            continue;
+        else {
+            try {
+                content = fs.readFileSync(filepath, 'utf-8');
+            }
+            catch {
+                allIssues.push({
+                    file: relPath,
+                    line: 1,
+                    severity: 'error',
+                    rule: 'read',
+                    message: (0, locale_1.t)('runner.read_error'),
+                });
+                continue;
+            }
         }
         const override = (0, config_1.findOverrides)(filepath);
         const effectiveConfig = override ? (0, config_1.mergeOverrides)(config, override) : config;
         allIssues.push(...runChecks(content, relPath, effectiveConfig));
     }
+    if (showProgress) {
+        process.stderr.write('\r' + ' '.repeat(60) + '\r');
+    }
     return allIssues;
 }
 function lintFilesParallel(files, config, rootDir) {
@@ -302,358 +326,9 @@ function lintFilesParallel(files, config, rootDir) {
             resolve([]);
     });
 }
-function findMatchingParen(s, start) {
-    if (s[start] !== '(')
-        return start;
-    let depth = 0;
-    for (let i = start; i < s.length; i++) {
-        if (s[i] === '"') {
-            i++;
-            while (i < s.length && s[i] !== '"') {
-                if (s[i] === '\\')
-                    i++;
-                i++;
-            }
-            continue;
-        }
-        if (s[i] === '(')
-            depth++;
-        else if (s[i] === ')') {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return s.length - 1;
-}
-function extractForm(s, start) {
-    let i = start;
-    while (i < s.length && s[i] === ' ')
-        i++;
-    if (i >= s.length)
-        return ['', i];
-    if (s[i] !== '(') {
-        const m = s.slice(i).match(/^\S+/);
-        if (m)
-            return [m[0], i + m[0].length];
-        return ['', i];
-    }
-    const end = findMatchingParen(s, i);
-    return [s.slice(i, end + 1), end + 1];
-}
-// ===== FIX APPLICATION =====
-exports.FIXABLE_RULES = 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',
-    'setq_multiple',
-    'append_single',
-    'nth_usage',
-    'setq_single_arg',
-    'extra_parens',
-    'empty_branch',
-    'comment_style',
-    'eq_usage',
-    'cond_simplify',
-    'self_compare',
-    'while_constant',
-    'redundant_list',
-]);
-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)
-            continue;
-        const set = fixesByRule.get(iss.rule) || new Set();
-        set.add(iss.line);
-        fixesByRule.set(iss.rule, set);
-    }
-    const fixableRules = exports.FIXABLE_RULES;
-    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 = lines[idx];
-            switch (rule) {
-                case 'redundant_quotes': {
-                    const fixed = lineContent.replace(/''(\S)/g, "'$1");
-                    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) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'redundant_nil_else': {
-                    const fixed = lineContent.replace(/\s+nil\s*\)$/, ')');
-                    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) {
-                        lines[idx] = m[2];
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'redundant_progn': {
-                    const proIdx = lineContent.indexOf('(progn ');
-                    if (proIdx !== -1) {
-                        const beforePro = lineContent.slice(0, proIdx);
-                        const close = findMatchingParen(lineContent, proIdx);
-                        if (close > proIdx) {
-                            const inner = lineContent.slice(proIdx + 7, close);
-                            const rest = lineContent.slice(close + 1);
-                            const fixed = beforePro + inner + rest;
-                            if (fixed !== lineContent) {
-                                lines[idx] = fixed;
-                                fixedLines.add(idx);
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'redundant_let': {
-                    const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
-                    if (fixed !== lineContent) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'quote_style': {
-                    const qIdx = lineContent.indexOf('(quote ');
-                    if (qIdx !== -1) {
-                        const beforeQ = lineContent.slice(0, qIdx);
-                        const close = findMatchingParen(lineContent, qIdx);
-                        if (close > qIdx) {
-                            const quoted = lineContent.slice(qIdx + 7, close);
-                            const rest = lineContent.slice(close + 1);
-                            const fixed = beforeQ + "'" + quoted + rest;
-                            if (fixed !== lineContent) {
-                                lines[idx] = fixed;
-                                fixedLines.add(idx);
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'redundant_if': {
-                    const pIdx = lineContent.indexOf('(progn ');
-                    if (pIdx !== -1) {
-                        const beforeP = lineContent.slice(0, pIdx);
-                        const close = findMatchingParen(lineContent, pIdx);
-                        if (close > pIdx) {
-                            const inner = lineContent.slice(pIdx + 7, close);
-                            const rest = lineContent.slice(close + 1);
-                            const fixed = beforeP + inner + rest;
-                            if (fixed !== lineContent) {
-                                lines[idx] = fixed;
-                                fixedLines.add(idx);
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'misplaced_else': {
-                    const ifStart = lineContent.indexOf('(if (not ');
-                    if (ifStart !== -1) {
-                        const notIdx = lineContent.indexOf('(not ', ifStart);
-                        if (notIdx === -1)
-                            break;
-                        const notClose = findMatchingParen(lineContent, notIdx);
-                        if (notClose <= notIdx)
-                            break;
-                        const ifClose = findMatchingParen(lineContent, ifStart);
-                        if (ifClose <= ifStart)
-                            break;
-                        const indent = lineContent.slice(0, ifStart);
-                        const condVar = lineContent.slice(notIdx + 5, notClose);
-                        const branchContent = lineContent.slice(notClose + 1, ifClose).trim();
-                        const [thenForm, thenEnd] = extractForm(branchContent, 0);
-                        const elseForm = branchContent.slice(thenEnd).trim();
-                        if (thenForm && elseForm) {
-                            const rest = lineContent.slice(ifClose + 1);
-                            const fixed = indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
-                            if (fixed !== lineContent) {
-                                lines[idx] = fixed;
-                                fixedLines.add(idx);
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'redundant_setq': {
-                    const trimmed = lines[idx].trim();
-                    if (/^\(setq\s+(\S+)\s+\1\s*\)$/.test(trimmed)) {
-                        lines.splice(idx, 1);
-                    }
-                    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(/\)\(/)) {
-                            lines[idx] = merged;
-                            fixedLines.add(idx);
-                        }
-                        else {
-                            const simplified = lineContent.replace(/\)\(setq\s+/g, '\n');
-                            if (simplified !== lineContent) {
-                                lines[idx] = simplified;
-                                fixedLines.add(idx);
-                            }
-                        }
-                    }
-                    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) {
-                                    lines[idx] = fixed;
-                                    fixedLines.add(idx);
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'nth_usage': {
-                    const fixed = lineContent.replace(/\(nth\s+0\s+/g, '(car ');
-                    if (fixed !== lineContent) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'setq_single_arg': {
-                    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) {
-                        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) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'comment_style': {
-                    const fixed = lineContent.replace(/^(\s*;)([^ ;|].*)$/gm, '$1 $2');
-                    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) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'cond_simplify': {
-                    const condIdx = lineContent.indexOf('(cond ');
-                    if (condIdx !== -1) {
-                        const condEnd = findMatchingParen(lineContent, condIdx);
-                        if (condEnd > condIdx) {
-                            const inner = lineContent.slice(condIdx + 6, condEnd).trim();
-                            const branchOpen = inner.indexOf('(');
-                            if (branchOpen !== -1) {
-                                const branchEnd = findMatchingParen(inner, branchOpen);
-                                if (branchEnd > branchOpen) {
-                                    const indent = lineContent.slice(0, condIdx);
-                                    const branchContent = inner.slice(branchOpen + 1, branchEnd).trim();
-                                    const space = branchContent.search(/\s+/);
-                                    if (space !== -1) {
-                                        const testExpr = branchContent.slice(0, space);
-                                        const bodyExpr = branchContent.slice(space).trim();
-                                        const rest = lineContent.slice(condEnd + 1);
-                                        const fixed = indent + '(if ' + testExpr + ' ' + bodyExpr + ')' + rest;
-                                        if (fixed !== lineContent) {
-                                            lines[idx] = fixed;
-                                            fixedLines.add(idx);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-                case 'self_compare': {
-                    const fixed = lineContent.replace(/\((?:[=/<>]+|eq|equal)\s+(\S+)\s+\1\s*\)/g, 'T');
-                    if (fixed !== lineContent) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-                case 'while_constant': {
-                    const trimmed = lines[idx].trim();
-                    const nilMatch = trimmed.match(/^\(\s*while\s+nil\s+(.*)\)\s*$/);
-                    if (nilMatch) {
-                        lines[idx] = lines[idx].replace(trimmed, 'nil');
-                    }
-                    break;
-                }
-                case 'redundant_list': {
-                    const fixed = lineContent.replace(/\(\s*list\s*\)/g, 'nil');
-                    if (fixed !== lineContent) {
-                        lines[idx] = fixed;
-                        fixedLines.add(idx);
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    return lines.join('\n');
-}
+var index_1 = require("./fixes/index");
+Object.defineProperty(exports, "applyFixes", { enumerable: true, get: function () { return index_1.applyFixesFromProviders; } });
+Object.defineProperty(exports, "FIXABLE_RULES", { enumerable: true, get: function () { return index_1.FIXABLE_RULES; } });
 function parseIgnoreFile(rootDir) {
     const ignoreFile = path.join(rootDir, '.atlisp-lint-ignore');
     if (!fs.existsSync(ignoreFile))

package/dist/types.d.ts

@@ -24,6 +24,7 @@ export interface DangerousCallsConfig {
     command_shell: Severity;
     startapp: Severity;
     vl_registry_write: Severity;
+    eval: Severity;
 }
 export interface ModuleRegistrationConfig extends CheckConfig {
     patterns: string[];

package/dist/utils.d.ts

@@ -7,6 +7,10 @@ export declare function codeLines(content: string): Generator<{
     text: string;
     stripped: string;
 }>;
+/** Find matching closing paren (string/comment aware) */
+export declare function findMatchingParen(s: string, start: number): number;
+/** Extract the next s-expression form starting at position */
+export declare function extractForm(s: string, start: number): [string, number];
 /** Extract string literals from a line */
 export declare function extractStrings(line: string): string[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripLine = stripLine;
 exports.stripLineRaw = stripLineRaw;
 exports.codeLines = codeLines;
+exports.findMatchingParen = findMatchingParen;
+exports.extractForm = extractForm;
 exports.extractStrings = extractStrings;
 /** Strip string contents and comments from a line of AutoLISP code */
 function stripLine(line) {
@@ -67,6 +69,47 @@ function* codeLines(content) {
         };
     }
 }
+/** Find matching closing paren (string/comment aware) */
+function findMatchingParen(s, start) {
+    if (s[start] !== '(')
+        return start;
+    let depth = 0;
+    for (let i = start; i < s.length; i++) {
+        if (s[i] === '"') {
+            i++;
+            while (i < s.length && s[i] !== '"') {
+                if (s[i] === '\\')
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (s[i] === '(')
+            depth++;
+        else if (s[i] === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return s.length - 1;
+}
+/** Extract the next s-expression form starting at position */
+function extractForm(s, start) {
+    let i = start;
+    while (i < s.length && s[i] === ' ')
+        i++;
+    if (i >= s.length)
+        return ['', i];
+    if (s[i] !== '(') {
+        const m = s.slice(i).match(/^\S+/);
+        if (m)
+            return [m[0], i + m[0].length];
+        return ['', i];
+    }
+    const end = findMatchingParen(s, i);
+    return [s.slice(i, end + 1), end + 1];
+}
 /** Extract string literals from a line */
 function extractStrings(line) {
     const strings = [];

package/dist/validate.js

@@ -89,6 +89,18 @@ const VALID_RULES = [
     'redundant_entmake',
     'missing_princ',
     'global_function_naming',
+    'command_s',
+    'zerop_usage',
+    'progn_in_body',
+    'if_progn_both',
+    'redundant_cond',
+    'selection_set_leak',
+    'empty_branch_cond',
+    'function_reference',
+    'progn_in_cond',
+    'redundant_car_cdr',
+    'equal_nil',
+    'redundant_and_or',
 ];
 const VALID_SEVERITIES = ['off', 'info', 'warn', 'error'];
 function validateConfig(config) {