@atlisp/lint 0.2.11 → 0.2.13

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[];
@@ -42,6 +43,10 @@ export interface SbclConfig {
     walk_exclude: string[];
     defmacro_allow_files: string[];
 }
+export interface ProjectAnalysisConfig {
+    maxFiles: number;
+    batchSize: number;
+}
 export interface SourceConfig {
     globs: string[];
     exclude: string[];
@@ -66,6 +71,7 @@ export interface LintConfig {
     namespace_header: NamespaceHeaderConfig;
     bare_function_names: BareFunctionNamesConfig;
     sbcl: SbclConfig;
+    project_analysis: ProjectAnalysisConfig;
     preset?: string;
 }
 export interface FormattedResult {

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) {

package/dist/visitor-runner.d.ts

@@ -1,4 +1,32 @@
 import { Issue, LintConfig } from './types';
 import { AstNode } from '@atlisp/parser';
+export interface CollectState {
+    openCount: number;
+    closeCount: number;
+    setqDefs: Map<string, {
+        line: number;
+        file: string;
+    }>;
+    symbolRefs: Map<string, number>;
+    condKeys: Map<number, Set<string>>;
+    defunScopes: Array<{
+        name: string;
+        params: string[];
+        body: AstNode[];
+        line: number;
+        file: string;
+    }>;
+    letScopes: Array<{
+        bindings: string[];
+        body: AstNode[];
+        line: number;
+    }>;
+    dangerousCalls: Array<{
+        name: string;
+        node: AstNode;
+    }>;
+    ssgetCount: number;
+    sssetCount: number;
+}
 export declare function runChecksWithVisitor(ast: AstNode, file: string, config: LintConfig, disableMap: Map<string, Set<number>>): Issue[];
 //# sourceMappingURL=visitor-runner.d.ts.map