@atlisp/lint 0.2.11 → 0.2.12

package/atlisp-lint.schema.json

@@ -196,6 +196,13 @@
         "walk_exclude": { "type": "array", "items": { "type": "string" }, "default": [".vscode", "vendor", ".git"] },
         "defmacro_allow_files": { "type": "array", "items": { "type": "string" }, "default": ["compat-cl"] }
       }
+    },
+    "project_analysis": {
+      "type": "object",
+      "properties": {
+        "maxFiles": { "type": "integer", "minimum": 1, "default": 500, "description": "Maximum number of files for cross-file analysis. Exceeding this threshold skips project analysis." },
+        "batchSize": { "type": "integer", "minimum": 1, "default": 50, "description": "Files processed per batch (reserved for future streaming)" }
+      }
     }
   }
 }

package/dist/checks/dangling-defun.d.ts

@@ -6,4 +6,11 @@ export declare function checkDanglingDefun(file: string, allDefuns: Map<string,
     file: string;
     line: number;
 }[]>): Issue[];
+export declare function checkDanglingDefunFromDefs(localDefuns: {
+    name: string;
+    line: number;
+}[], allReferences: Map<string, {
+    file: string;
+    line: number;
+}[]>, file: string): Issue[];
 //# sourceMappingURL=dangling-defun.d.ts.map

package/dist/checks/dangling-defun.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDanglingDefun = checkDanglingDefun;
+exports.checkDanglingDefunFromDefs = checkDanglingDefunFromDefs;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const fs = __importStar(require("fs"));
@@ -64,4 +65,22 @@ function checkDanglingDefun(file, allDefuns, allReferences) {
     }
     return issues;
 }
+function checkDanglingDefunFromDefs(localDefuns, allReferences, file) {
+    const issues = [];
+    for (const defun of localDefuns) {
+        const refs = allReferences.get(defun.name) || [];
+        const calledElsewhere = refs.some(r => r.file !== file);
+        const calledLocally = refs.some(r => r.file === file);
+        if (!calledLocally && !calledElsewhere) {
+            issues.push({
+                file,
+                line: defun.line,
+                severity: 'warn',
+                rule: 'dangling_defun',
+                message: (0, locale_1.t)('dangling_defun', defun.name),
+            });
+        }
+    }
+    return issues;
+}
 //# sourceMappingURL=dangling-defun.js.map

package/dist/checks/unused-package-dep.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
 export declare function checkUnusedPackageDep(file: string): Issue[];
+export declare function checkUnusedPackageDepFromContent(file: string, content: string): Issue[];
 //# sourceMappingURL=unused-package-dep.d.ts.map

package/dist/checks/unused-package-dep.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkUnusedPackageDep = checkUnusedPackageDep;
+exports.checkUnusedPackageDepFromContent = checkUnusedPackageDepFromContent;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const fs = __importStar(require("fs"));
@@ -90,4 +91,56 @@ function checkUnusedPackageDep(file) {
     }
     return issues;
 }
+function checkUnusedPackageDepFromContent(file, content) {
+    const issues = [];
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
+    if (inPackageNodes.length === 0)
+        return issues;
+    const allPackages = new Set();
+    for (const node of inPackageNodes) {
+        if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            allPackages.add(node.children[1].name);
+        }
+    }
+    const usedSymbols = new Set();
+    const allLists = (0, parser_1.astFindAll)(ast, n => n.type === 'list');
+    for (const node of allLists) {
+        if (!node.children || node.children.length === 0)
+            continue;
+        const car = node.children[0];
+        if (car.type === 'symbol' && car.name) {
+            const parts = car.name.split(':');
+            if (parts.length === 2 && parts[0] && parts[1]) {
+                usedSymbols.add(parts[0]);
+            }
+        }
+        for (let i = 1; i < node.children.length; i++) {
+            const child = node.children[i];
+            if (child.type === 'symbol' && child.name) {
+                const parts = child.name.split(':');
+                if (parts.length === 2 && parts[0] && parts[1]) {
+                    usedSymbols.add(parts[0]);
+                }
+            }
+        }
+    }
+    const mainPackage = inPackageNodes.length > 0 && inPackageNodes[0].children && inPackageNodes[0].children[1]
+        ? inPackageNodes[0].children[1].name || ''
+        : '';
+    allPackages.delete(mainPackage);
+    for (const pkg of allPackages) {
+        if (!usedSymbols.has(pkg)) {
+            const node = inPackageNodes.find(n => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === pkg);
+            issues.push({
+                file,
+                line: node ? node.pos.line : 1,
+                severity: 'warn',
+                rule: 'unused_package_dep',
+                message: (0, locale_1.t)('unused_package_dep', pkg),
+            });
+        }
+    }
+    return issues;
+}
 //# sourceMappingURL=unused-package-dep.js.map

package/dist/config.js

@@ -172,6 +172,10 @@ const DEFAULT_CONFIG = {
         walk_exclude: ['.vscode', 'vendor', '.git'],
         defmacro_allow_files: ['compat-cl'],
     },
+    project_analysis: {
+        maxFiles: 500,
+        batchSize: 50,
+    },
 };
 function loadConfig(configPath) {
     if (configPath) {

package/dist/project.js

@@ -42,9 +42,8 @@ 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 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 +53,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 +68,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 +95,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 +113,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 +145,148 @@ 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, filepath, relPath, allIssues) {
+    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);
+        }
     }
-    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 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 +303,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,87 +319,19 @@ 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);
-                }
-            }
-        }
-        // 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}`,
-                            });
-                        }
-                    }
-                }
-            }
+            const argIssues = checkArgCountProject(filepath, defunArgs, callArgCounts, symbols, relPath);
+            allIssues.push(...argIssues);
+        }
+    }
+    // Module cycle check: run DFS once (not per file)
+    const cycleCheckFile = fileContents.keys().next().value;
+    if (cycleCheckFile) {
+        const override = findProjectOverride(cycleCheckFile);
+        const checks = override?.checks || config.checks;
+        if (checks['module_cycle'] !== 'off') {
+            const relPath = path.relative(rootDir, cycleCheckFile);
+            checkModuleCycle(moduleDeps, rootDir, cycleCheckFile, relPath, allIssues);
         }
     }
     return allIssues;

package/dist/types.d.ts

@@ -42,6 +42,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 +70,7 @@ export interface LintConfig {
     namespace_header: NamespaceHeaderConfig;
     bare_function_names: BareFunctionNamesConfig;
     sbcl: SbclConfig;
+    project_analysis: ProjectAnalysisConfig;
     preset?: string;
 }
 export interface FormattedResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",