@atlisp/lint 0.2.10 → 0.2.12

package/README.md

@@ -128,6 +128,7 @@ npx @atlisp/lint --format-check
 | `shadow_builtin` | warn | 最佳实践 | defun 覆盖内置函数 |
 | `dynamic_doc` | warn | 最佳实践 | C: 命令缺少 (princ) |
 | `open_without_close` | warn | 最佳实践 | open/close 数量不匹配 |
+| `strcat_or_arg` | error | 正确性 | strcat 参数中使用 or（or 返回 T/nil） |
 | `strcat_usage` | warn | 最佳实践 | + 拼接而非 strcat |
 | `cond_simplify` | warn | 风格 | 单分支 cond 可简化为 if |
 | `arg_count` | warn | 最佳实践 | 参数数量不匹配 |

package/atlisp-lint.default.json

@@ -59,13 +59,14 @@
     "extra_parens": "warn",
     "arg_count": "error",
     "builtin_arg_count": "error",
+    "strcat_or_arg": "error",
     "strcat_usage": "warn",
     "cond_simplify": "warn",
     "quote_style": "warn",
     "eq_usage": "warn",
     "lambda_syntax": "off",
     "comment_style": "warn",
-    "empty_catch": "warn",
+    "empty_catch": "info",
     "nth_usage": "warn",
     "append_single": "warn",
     "setq_multiple": "warn",

package/atlisp-lint.schema.json

@@ -59,7 +59,7 @@
         "duplicate_defun": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "dynamic_doc": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "empty_branch": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
-        "empty_catch": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "empty_catch": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "empty_comment": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "encoding": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
         "entget_in_loop": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
@@ -111,6 +111,7 @@
         "shadow_builtin": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "single_arg_and_or": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "startapp": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "strcat_or_arg": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
         "strcat_usage": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "string_concat_loop": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "token_in_url": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
@@ -195,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

@@ -102,13 +102,14 @@ const DEFAULT_CONFIG = {
         extra_parens: 'warn',
         arg_count: 'warn',
         builtin_arg_count: 'error',
+        strcat_or_arg: 'error',
         strcat_usage: 'info',
         cond_simplify: 'info',
         quote_style: 'info',
         eq_usage: 'warn',
         lambda_syntax: 'off',
         comment_style: 'info',
-        empty_catch: 'warn',
+        empty_catch: 'info',
         nth_usage: 'info',
         append_single: 'info',
         setq_multiple: 'warn',
@@ -120,7 +121,7 @@ const DEFAULT_CONFIG = {
         shadow_builtin: 'warn',
         dynamic_doc: 'warn',
         loop_optimization: 'info',
-        format_indent: 'warn',
+        format_indent: 'off',
         redundant_if: 'info',
         unused_catch_result: 'info',
         string_concat_loop: 'info',
@@ -171,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/locale.js

@@ -94,6 +94,7 @@ const messages = {
         'index.watch_status': '{0} files checked: {1} error(s), {2} warning(s)',
         'index.format_unstable': 'Formatting is not idempotent — re-running formatCode produces different output',
         unused_catch_result: 'vl-catch-all-apply result used as boolean — use vl-catch-all-error-p to check',
+        strcat_or_arg: 'or in strcat argument — or returns T/nil, not a string',
         string_concat_loop: 'String concatenation inside {0} — move strcat outside the loop for performance',
         if_without_else: 'if without else branch — else is implicitly nil, which is idiomatic in Lisp',
         redundant_list: '(list) evaluates to nil — use nil directly',
@@ -222,6 +223,7 @@ Options:
         'index.watch_status': '已检查 {0} 个文件: {1} 个错误, {2} 个警告',
         'index.format_unstable': '格式化结果不稳定——再次格式化后输出不同',
         unused_catch_result: 'vl-catch-all-apply 的结果被当作布尔值使用——应用 vl-catch-all-error-p 检查',
+        strcat_or_arg: 'strcat 参数中使用了 or 函数调用（or 返回 T 或 nil，不是字符串）',
         string_concat_loop: '循环 {0} 内使用了字符串拼接——为提升性能请将 strcat 移到循环外',
         if_without_else: 'if 没有 else 分支——else 默认为 nil 是 Lisp 惯用写法',
         redundant_list: '(list) 等于 nil——请直接使用 nil',

package/dist/presets.js

@@ -50,13 +50,14 @@ exports.PRESETS = {
             extra_parens: 'warn',
             arg_count: 'warn',
             builtin_arg_count: 'error',
+            strcat_or_arg: 'error',
             strcat_usage: 'info',
             cond_simplify: 'info',
             quote_style: 'info',
             eq_usage: 'warn',
             lambda_syntax: 'off',
             comment_style: 'info',
-            empty_catch: 'warn',
+            empty_catch: 'info',
             nth_usage: 'info',
             append_single: 'info',
             setq_multiple: 'warn',
@@ -133,6 +134,7 @@ exports.PRESETS = {
             extra_parens: 'error',
             arg_count: 'error',
             builtin_arg_count: 'error',
+            strcat_or_arg: 'error',
             strcat_usage: 'error',
             cond_simplify: 'error',
             quote_style: 'error',
@@ -151,7 +153,7 @@ exports.PRESETS = {
             shadow_builtin: 'error',
             dynamic_doc: 'error',
             loop_optimization: 'warn',
-            format_indent: 'warn',
+            format_indent: 'off',
             redundant_if: 'error',
             module_registration: 'error',
             namespace_header: 'error',

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/rules.js

@@ -179,6 +179,12 @@ exports.RULES = [
     { name: 'shadow_builtin', defaultSeverity: 'warn', description: '检测覆盖内置函数的 defun', category: '最佳实践' },
     { name: 'single_arg_and_or', defaultSeverity: 'info', description: '检测单参数 and/or 建议简化', category: '风格' },
     { name: 'startapp', defaultSeverity: 'warn', description: '检测 startapp 调用（启动外部程序）', category: '安全' },
+    {
+        name: 'strcat_or_arg',
+        defaultSeverity: 'error',
+        description: '检测 strcat 参数中使用 or（or 返回 T/nil，非字符串）',
+        category: '正确性',
+    },
     {
         name: 'strcat_usage',
         defaultSeverity: 'info',

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/dist/validate.js

@@ -62,6 +62,7 @@ const VALID_RULES = [
     'shadow_builtin',
     'single_arg_and_or',
     'startapp',
+    'strcat_or_arg',
     'strcat_usage',
     'token_in_url',
     'trailing_paren',

package/dist/visitor-runner.js

@@ -664,6 +664,29 @@ function runChecksWithVisitor(ast, file, config, disableMap) {
             }
         });
     }
+    // strcat_or_arg
+    if (checks['strcat_or_arg'] !== 'off') {
+        visitor.on('*', node => {
+            if (node.type === 'list' &&
+                node.children &&
+                node.children.length > 1 &&
+                node.children[0].type === 'symbol' &&
+                node.children[0].name === 'strcat') {
+                if (isInQuote(node))
+                    return;
+                for (let i = 1; i < node.children.length; i++) {
+                    const arg = node.children[i];
+                    if (arg.type === 'list' &&
+                        arg.children &&
+                        arg.children.length > 0 &&
+                        arg.children[0].type === 'symbol' &&
+                        arg.children[0].name === 'or') {
+                        addIssue('strcat_or_arg', arg.pos.line, (0, locale_1.t)('strcat_or_arg'));
+                    }
+                }
+            }
+        });
+    }
     // redundant_list
     if (checks['redundant_list'] !== 'off') {
         visitor.on('list', node => {

package/package.json

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