@atlisp/lint 0.2.11 → 0.2.13

package/dist/project.js

@@ -41,10 +41,11 @@ const dangling_defun_1 = require("./checks/dangling-defun");
 const missing_export_1 = require("./checks/missing-export");
 const unused_package_dep_1 = require("./checks/unused-package-dep");
 const duplicate_defun_1 = require("./checks/duplicate-defun");
+const builtin_arg_count_1 = require("./checks/builtin-arg-count");
+const config_1 = require("./config");
 const locale_1 = require("./locale");
-function collectDefuns(file) {
-    const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+const locale_2 = require("./locale");
+function collectDefunsFromAst(ast) {
     const results = [];
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
@@ -54,9 +55,7 @@ function collectDefuns(file) {
     }
     return results;
 }
-function collectReferences(file) {
-    const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+function collectReferencesFromAst(ast) {
     const results = [];
     const allCalls = (0, parser_1.astFindAll)(ast, n => {
         if (n.type !== 'list' || !n.children || n.children.length === 0)
@@ -71,9 +70,7 @@ function collectReferences(file) {
     }
     return results;
 }
-function countFunctionArgs(file) {
-    const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+function countFunctionArgsFromAst(ast) {
     const result = new Map();
     const defunNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
     for (const node of defunNodes) {
@@ -100,9 +97,7 @@ function countFunctionArgs(file) {
     }
     return result;
 }
-function countCallArgs(file) {
-    const content = fs.readFileSync(file, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+function countCallArgsFromAst(ast) {
     const result = new Map();
     const allCalls = (0, parser_1.astFindAll)(ast, n => {
         if (n.type !== 'list' || !n.children || n.children.length === 0)
@@ -120,9 +115,7 @@ function countCallArgs(file) {
     }
     return result;
 }
-function findModuleDeps(filepath) {
-    const content = fs.readFileSync(filepath, 'utf-8');
-    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+function findModuleDepsFromAst(ast) {
     const imports = [];
     const exports = [];
     const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
@@ -154,56 +147,167 @@ function findModuleDeps(filepath) {
     }
     return { imports, exports };
 }
-function collectAllModuleDeps(files) {
-    const deps = new Map();
-    for (const f of files) {
-        deps.set(f, findModuleDeps(f));
+function checkArgCountProject(filepath, defunArgs, callArgCounts, symbols, relPath) {
+    const issues = [];
+    const fileArgs = defunArgs.get(filepath);
+    if (!fileArgs)
+        return issues;
+    const callArgs = callArgCounts.get(filepath);
+    if (!callArgs)
+        return issues;
+    for (const [fnName, calls] of callArgs) {
+        const defs = symbols.defuns.get(fnName);
+        if (!defs)
+            continue;
+        const defArgCount = fileArgs.get(fnName);
+        if (defArgCount === undefined)
+            continue;
+        let allMatch = true;
+        for (const def of defs) {
+            const otherFileArgs = defunArgs.get(def.file);
+            if (otherFileArgs && otherFileArgs.get(fnName) !== defArgCount) {
+                allMatch = false;
+                break;
+            }
+        }
+        if (!allMatch)
+            continue;
+        for (const call of calls) {
+            if (call.count !== defArgCount) {
+                issues.push({
+                    file: relPath,
+                    line: call.line,
+                    severity: 'warn',
+                    rule: 'arg_count_project',
+                    message: (0, locale_2.t)('arg_count_project', fnName, String(call.count), String(defArgCount)),
+                });
+            }
+        }
+    }
+    return issues;
+}
+function checkModuleCycle(moduleDeps, rootDir, allIssues) {
+    const visited = new Set();
+    const stack = new Set();
+    const cyclePath = [];
+    const exportIndex = new Map();
+    for (const [f, deps] of moduleDeps) {
+        for (const exp of deps.exports) {
+            const list = exportIndex.get(exp) || [];
+            list.push(f);
+            exportIndex.set(exp, list);
+        }
+    }
+    const dfs = (current) => {
+        if (stack.has(current)) {
+            const idx = cyclePath.indexOf(current);
+            const cycle = cyclePath.slice(idx).concat(current);
+            for (const f of cycle) {
+                const override = (0, config_1.findOverrides)(f);
+                const checks = override?.checks || {};
+                if (checks['module_cycle'] === 'off')
+                    return false;
+            }
+            const displayCycle = cycle.map(c => path.relative(rootDir, c)).join(' → ');
+            allIssues.push({
+                file: path.relative(rootDir, current),
+                line: 1,
+                severity: 'warn',
+                rule: 'module_cycle',
+                message: `Module dependency cycle detected: ${displayCycle}`,
+            });
+            return true;
+        }
+        if (visited.has(current))
+            return false;
+        visited.add(current);
+        stack.add(current);
+        cyclePath.push(current);
+        try {
+            const deps = moduleDeps.get(current);
+            if (deps) {
+                for (const imp of deps.imports) {
+                    const providerFiles = exportIndex.get(imp);
+                    if (providerFiles) {
+                        for (const otherFile of providerFiles) {
+                            if (dfs(otherFile))
+                                return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        finally {
+            cyclePath.pop();
+            stack.delete(current);
+        }
+    };
+    for (const f of moduleDeps.keys()) {
+        if (!visited.has(f)) {
+            dfs(f);
+        }
     }
-    return deps;
 }
 function lintProject(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
     const symbols = { defuns: new Map(), references: new Map() };
+    const maxFiles = config.project_analysis?.maxFiles ?? 500;
+    if (files.length > maxFiles) {
+        const msg = `${files.length} files exceeds project_analysis.maxFiles (${maxFiles}). Skipping cross-file analysis. To increase, set project_analysis.maxFiles in config.`;
+        console.warn(`[atlisp-lint] ${msg}`);
+        return [];
+    }
     const fileContents = new Map();
+    const defunArgs = new Map();
+    const callArgCounts = new Map();
+    const moduleDeps = new Map();
+    // Phase A: Streaming collection — one file at a time, keep only metadata
     for (const filepath of files) {
+        let content;
         try {
-            const content = fs.readFileSync(filepath, 'utf-8');
-            fileContents.set(filepath, content);
+            content = fs.readFileSync(filepath, 'utf-8');
         }
         catch {
             continue;
         }
-    }
-    // Build project symbol table
-    for (const [filepath] of fileContents) {
-        const defunList = collectDefuns(filepath);
+        const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+        // Extract all metadata from a single AST parse
+        const defunList = collectDefunsFromAst(ast);
         for (const d of defunList) {
             const list = symbols.defuns.get(d.name) || [];
             list.push({ file: filepath, line: d.line });
             symbols.defuns.set(d.name, list);
         }
-        const refList = collectReferences(filepath);
+        const refList = collectReferencesFromAst(ast);
         for (const r of refList) {
             const list = symbols.references.get(r.name) || [];
             list.push({ file: filepath, line: r.line });
             symbols.references.set(r.name, list);
         }
+        defunArgs.set(filepath, countFunctionArgsFromAst(ast));
+        callArgCounts.set(filepath, countCallArgsFromAst(ast));
+        moduleDeps.set(filepath, findModuleDepsFromAst(ast));
+        // Cache file content for checks that still need it
+        fileContents.set(filepath, content);
+        // AST goes out of scope here → GC reclaims it
     }
-    // New: build module dependency graph
-    const moduleDeps = collectAllModuleDeps(Array.from(fileContents.keys()));
-    // New: collect function arg counts per file
-    const defunArgs = new Map();
-    for (const [filepath] of fileContents) {
-        defunArgs.set(filepath, countFunctionArgs(filepath));
-    }
+    // Phase B: Cross-file checks using only symbol tables
     for (const [filepath] of fileContents) {
         const relPath = path.relative(rootDir, filepath);
-        const override = findProjectOverride(filepath);
+        const override = (0, config_1.findOverrides)(filepath);
         const checks = override?.checks || config.checks;
-        // Existing checks
         if (checks['dangling_defun'] !== 'off') {
-            const danglingIssues = (0, dangling_defun_1.checkDanglingDefun)(filepath, symbols.defuns, symbols.references);
+            const defunList = [];
+            for (const [name, locations] of symbols.defuns) {
+                for (const loc of locations) {
+                    if (loc.file === filepath) {
+                        defunList.push({ name, line: loc.line });
+                    }
+                }
+            }
+            const danglingIssues = (0, dangling_defun_1.checkDanglingDefunFromDefs)(defunList, symbols.references, filepath);
             for (const iss of danglingIssues) {
                 iss.file = relPath;
                 allIssues.push(iss);
@@ -220,10 +324,13 @@ function lintProject(files, config, rootDir) {
             }
         }
         if (checks['unused_package_dep'] !== 'off') {
-            const depIssues = (0, unused_package_dep_1.checkUnusedPackageDep)(filepath);
-            for (const iss of depIssues) {
-                iss.file = relPath;
-                allIssues.push(iss);
+            const content = fileContents.get(filepath);
+            if (content) {
+                const depIssues = (0, unused_package_dep_1.checkUnusedPackageDepFromContent)(filepath, content);
+                for (const iss of depIssues) {
+                    iss.file = relPath;
+                    allIssues.push(iss);
+                }
             }
         }
         if (checks['duplicate_defun'] !== 'off') {
@@ -233,108 +340,49 @@ function lintProject(files, config, rootDir) {
                 allIssues.push(iss);
             }
         }
-        // New: module cycle detection
-        if (checks['module_cycle'] !== 'off') {
-            const visited = new Set();
-            const stack = new Set();
-            const cyclePath = [];
-            const dfs = (current) => {
-                if (stack.has(current)) {
-                    const idx = cyclePath.indexOf(current);
-                    const cycle = cyclePath.slice(idx).concat(current);
-                    const displayCycle = cycle.map(c => path.relative(rootDir, c)).join(' → ');
-                    allIssues.push({
-                        file: relPath,
-                        line: 1,
-                        severity: 'warn',
-                        rule: 'module_cycle',
-                        message: `Module dependency cycle detected: ${displayCycle}`,
-                    });
-                    return true;
-                }
-                if (visited.has(current))
-                    return false;
-                visited.add(current);
-                stack.add(current);
-                cyclePath.push(current);
-                const deps = moduleDeps.get(current);
-                if (deps) {
-                    for (const imp of deps.imports) {
-                        for (const [otherFile, otherDeps] of moduleDeps) {
-                            if (otherDeps.exports.includes(imp)) {
-                                if (dfs(otherFile))
-                                    return true;
-                            }
-                        }
-                    }
-                }
-                cyclePath.pop();
-                stack.delete(current);
-                return false;
-            };
-            for (const f of moduleDeps.keys()) {
-                if (!visited.has(f)) {
-                    dfs(f);
+        if (checks['arg_count_project'] !== 'off') {
+            const argIssues = checkArgCountProject(filepath, defunArgs, callArgCounts, symbols, relPath);
+            allIssues.push(...argIssues);
+        }
+        if (checks['function_reference'] !== 'off') {
+            const definedHere = new Set();
+            for (const [name, locations] of symbols.defuns) {
+                for (const loc of locations) {
+                    if (loc.file === filepath)
+                        definedHere.add(name);
                 }
             }
-        }
-        // New: signature mismatch check
-        if (checks['arg_count_project'] !== 'off') {
-            const fileArgs = defunArgs.get(filepath);
-            if (fileArgs) {
-                const callArgs = countCallArgs(filepath);
-                for (const [fnName, calls] of callArgs) {
-                    const defs = symbols.defuns.get(fnName);
-                    if (!defs)
-                        continue;
-                    const defArgCount = fileArgs.get(fnName);
-                    if (defArgCount === undefined)
-                        continue;
-                    // Only check if all definitions agree
-                    let allMatch = true;
-                    for (const def of defs) {
-                        const otherFileArgs = defunArgs.get(def.file);
-                        if (otherFileArgs && otherFileArgs.get(fnName) !== defArgCount) {
-                            allMatch = false;
-                            break;
-                        }
-                    }
-                    if (!allMatch)
-                        continue;
-                    for (const call of calls) {
-                        if (call.count !== defArgCount) {
-                            allIssues.push({
-                                file: relPath,
-                                line: call.line,
-                                severity: 'warn',
-                                rule: 'arg_count_project',
-                                message: `Function '${fnName}' called with ${call.count} arguments but defined with ${defArgCount}`,
-                            });
-                        }
+            for (const [name, refs] of symbols.references) {
+                if (builtin_arg_count_1.BUILTIN_FUNCTIONS.has(name))
+                    continue;
+                if (definedHere.has(name))
+                    continue;
+                if (symbols.defuns.has(name))
+                    continue;
+                for (const ref of refs) {
+                    if (ref.file === filepath) {
+                        allIssues.push({
+                            file: relPath,
+                            line: ref.line,
+                            severity: 'warn',
+                            rule: 'function_reference',
+                            message: (0, locale_2.t)('function_reference', name),
+                        });
                     }
                 }
             }
         }
     }
-    return allIssues;
-}
-function findProjectOverride(filepath) {
-    let dir = path.dirname(filepath);
-    for (;;) {
-        const cfgPath = path.join(dir, '.atlisp-lint.json');
-        if (fs.existsSync(cfgPath)) {
-            try {
-                return JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
-            }
-            catch {
-                return null;
-            }
+    // Module cycle check: run DFS once (not per file)
+    const cycleCheckFile = fileContents.keys().next().value;
+    if (cycleCheckFile) {
+        const override = (0, config_1.findOverrides)(cycleCheckFile);
+        const checks = override?.checks || config.checks;
+        if (checks['module_cycle'] !== 'off') {
+            checkModuleCycle(moduleDeps, rootDir, allIssues);
         }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
     }
+    return allIssues;
 }
 function findPackageDir(filepath) {
     let dir = path.dirname(filepath);

package/dist/rules.d.ts

@@ -7,4 +7,5 @@ export interface RuleDoc {
 export declare const RULES: RuleDoc[];
 export declare function generateRulesMarkdown(): string;
 export declare function generateSchemaHint(): string;
+export declare function generateRuleDetail(ruleName: string): string;
 //# sourceMappingURL=rules.d.ts.map

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