@atlisp/lint 0.1.16 → 0.1.19

package/dist/formatters-sarif.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSarif = formatSarif;
+function formatSarif(issues, errorCount, warningCount) {
+    const results = issues.map(iss => {
+        const level = iss.severity === 'error' ? 'error' : 'warning';
+        return {
+            level,
+            message: {
+                text: iss.message,
+            },
+            locations: [
+                {
+                    physicalLocation: {
+                        artifactLocation: {
+                            uri: iss.file,
+                        },
+                        region: {
+                            startLine: iss.line || 1,
+                        },
+                    },
+                },
+            ],
+            ruleId: iss.rule,
+        };
+    });
+    const sarif = {
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        version: '2.1.0',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: '@atlisp/lint',
+                        version: '0.1.18',
+                        informationUri: 'https://github.com/atlisp/lint',
+                        rules: issues.map(iss => ({
+                            id: iss.rule,
+                            name: iss.rule,
+                            shortDescription: { text: iss.message },
+                            properties: { severity: iss.severity },
+                        })),
+                    },
+                },
+                results,
+                summary: {
+                    errorCount,
+                    warningCount,
+                },
+            },
+        ],
+    };
+    return JSON.stringify(sarif, null, 2);
+}
+//# sourceMappingURL=formatters-sarif.js.map

package/dist/index.js

@@ -42,6 +42,8 @@ const runner_1 = require("./runner");
 const project_1 = require("./project");
 const sbcl_1 = require("./sbcl");
 const formatters_1 = require("./formatters");
+const formatters_sarif_1 = require("./formatters-sarif");
+const formatters_html_1 = require("./formatters-html");
 const formatter_1 = require("./formatter");
 const locale_1 = require("./locale");
 const cache_1 = require("./cache");
@@ -52,6 +54,8 @@ function parseArgs() {
         src: [],
         test: [],
         staged: false,
+        diff: false,
+        changed: '',
         format: 'default',
         init: false,
         installHook: false,
@@ -82,6 +86,12 @@ function parseArgs() {
             case '--staged':
                 opts.staged = true;
                 break;
+            case '--diff':
+                opts.diff = true;
+                break;
+            case '--changed':
+                opts.changed = argv[++i] || 'main';
+                break;
             case '--format':
                 opts.format = argv[++i];
                 break;
@@ -163,6 +173,23 @@ function* walkFiles(dir, rootDir, regex) {
         }
     }
 }
+function collectChangedFiles(rootDir, baseBranch) {
+    try {
+        const output = (0, child_process_1.execSync)(`git diff --name-only --diff-filter=ACM ${baseBranch}`, {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        return output
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l.endsWith('.lsp'))
+            .map(l => path.resolve(rootDir, l))
+            .filter(f => fs.existsSync(f));
+    }
+    catch {
+        return [];
+    }
+}
 // Placeholder regex (dynamically constructed to avoid no-control-regex)
 const GLOB_PLACEHOLDER = '\x00GLOB\x00';
 const GLOB_RE = new RegExp(GLOB_PLACEHOLDER, 'g');
@@ -294,7 +321,13 @@ async function main() {
             return;
         }
         // Collect files
-        const files = opts.staged ? collectStagedFiles(rootDir) : collectFiles(rootDir, opts, config);
+        const files = opts.staged
+            ? collectStagedFiles(rootDir)
+            : opts.diff
+                ? collectChangedFiles(rootDir, 'HEAD')
+                : opts.changed
+                    ? collectChangedFiles(rootDir, opts.changed)
+                    : collectFiles(rootDir, opts, config);
         if (files.length === 0) {
             console.log((0, locale_1.t)('index.no_files'));
             return;
@@ -330,7 +363,7 @@ async function main() {
         }
         // --watch mode
         if (opts.watch) {
-            (0, watch_1.watchFiles)(files, { rootDir, format: opts.format, config });
+            (0, watch_1.watchFiles)(files, { rootDir, format: (opts.format === 'sarif' || opts.format === 'html' ? 'default' : opts.format), config });
             return;
         }
         // --fix mode: auto-fix before linting
@@ -478,6 +511,12 @@ async function main() {
         if (opts.format === 'json') {
             console.log((0, formatters_1.formatJson)(issues, errorCount, warningCount));
         }
+        else if (opts.format === 'sarif') {
+            console.log((0, formatters_sarif_1.formatSarif)(issues, errorCount, warningCount));
+        }
+        else if (opts.format === 'html') {
+            console.log((0, formatters_html_1.formatHtml)(issues, errorCount, warningCount));
+        }
         else {
             console.log((0, formatters_1.formatDefault)(issues, fileContents));
         }

package/dist/locale.js

@@ -38,8 +38,6 @@ const messages = {
         unused_let_binding: "Let binding '{0}' is never used",
         recursive_call: "Function '{0}' calls itself — possible infinite recursion",
         variable_shadow: "Variable '{0}' is set with setq inside a let that binds the same name",
-        'redundant_cond.single': 'Single-clause {0} — simplify to (if ...)',
-        'redundant_cond.t_last': '{0} with T as last clause condition — use (if ...) else branch instead',
         unused_local_fun: "Local function/variable '{0}' is defined in defun with / but never used",
         multiple_setq: 'Consecutive (setq ...) forms — consider merging into a single (setq ...)',
         redundant_quotes: "Redundant double quote — ''x can be simplified to 'x",
@@ -91,6 +89,14 @@ const messages = {
         'index.watch_hint': 'Press Ctrl+C to stop',
         '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',
+        string_concat_loop: 'String concatenation inside {0} — move strcat outside the loop for performance',
+        if_without_else: 'if has no else branch and the return value is used — add nil else for clarity',
+        redundant_list: '(list) evaluates to nil — use nil directly',
+        entget_in_loop: 'entget inside loop — cache entget result before the loop for performance',
+        promise_handler: 'vlax-invoke/vlax-invoke-method without callback handler — results may be lost',
+        module_cycle: 'Module dependency cycle detected — may cause initialization issues',
+        arg_count_project: "Function '{0}' called with {1} arguments but defined with {2} (cross-file)",
         'help.text': `@atlisp/lint - AutoLISP static analysis tool
 
 Usage: atlisp-lint [options]
@@ -113,8 +119,10 @@ Options:
   --hook-args <args>     Custom pre-commit hook arguments (with --install-hook)
   --help                 Show this help message
   --version              Show version number
-  --format-code          Auto-format code indentation
-  --format-check         Check if files are formatted (exit 1 if not)`,
+  --format-code            Auto-format code indentation
+  --format-check         Check if files are formatted (exit 1 if not)
+  --diff                 Only check files changed since last commit
+  --changed <branch>     Only check files changed against a branch (default: main)`,
     },
     zh: {
         'parens.mismatch': "括号不匹配：{0} 个 '(' vs {1} 个 ')'（{2}）",
@@ -150,8 +158,6 @@ Options:
         unused_let_binding: "let 绑定 '{0}' 从未被使用",
         recursive_call: "函数 '{0}' 调用了自身——可能存在无限递归",
         variable_shadow: "变量 '{0}' 在 let 绑定了相同名称后被 setq 赋值",
-        'redundant_cond.single': '单子句 {0} ——建议简化为 (if ...)',
-        'redundant_cond.t_last': '{0} 的最后一条子句条件为 T ——建议改用 (if ...) else 分支',
         unused_local_fun: "局部函数/变量 '{0}' 在 defun 的 / 后定义但从未使用",
         multiple_setq: '连续多个 (setq ...) ——建议合并为一个 (setq ...)',
         redundant_quotes: "冗余双引号 —— ''x 可以简化为 'x",
@@ -203,6 +209,14 @@ Options:
         'index.watch_hint': '按 Ctrl+C 停止',
         'index.watch_status': '已检查 {0} 个文件: {1} 个错误, {2} 个警告',
         'index.format_unstable': '格式化结果不稳定——再次格式化后输出不同',
+        unused_catch_result: 'vl-catch-all-apply 的结果被当作布尔值使用——应用 vl-catch-all-error-p 检查',
+        string_concat_loop: '循环 {0} 内使用了字符串拼接——为提升性能请将 strcat 移到循环外',
+        if_without_else: 'if 没有 else 分支且返回值被使用——建议添加 nil else 分支',
+        redundant_list: '(list) 等于 nil——请直接使用 nil',
+        entget_in_loop: '循环内使用了 entget——请在循环外缓存 entget 结果',
+        promise_handler: 'vlax-invoke/vlax-invoke-method 没有回调处理器——结果可能丢失',
+        module_cycle: '检测到模块循环依赖——可能导致初始化问题',
+        arg_count_project: "函数 '{0}' 调用时传入了 {1} 个参数，但定义为 {2} 个（跨文件）",
         'help.text': `@atlisp/lint - AutoLISP 静态分析工具
 
 用法: atlisp-lint [选项]
@@ -226,7 +240,9 @@ Options:
   --help                  显示此帮助信息
   --version               显示版本号
   --format-code           自动格式化代码缩进
-  --format-check          检查文件是否已格式化（未格式化则退出码为 1）`,
+  --format-check          检查文件是否已格式化（未格式化则退出码为 1）
+  --diff                  仅检查自上次提交后变更的文件
+  --changed <分支>        仅检查相对于某分支有变更的文件（默认：main）`,
     },
 };
 let currentLocale = 'zh';

package/dist/presets.js

@@ -26,7 +26,6 @@ exports.PRESETS = {
             unused_let_binding: 'warn',
             recursive_call: 'warn',
             variable_shadow: 'warn',
-            redundant_cond: 'warn',
             unused_local_fun: 'warn',
             multiple_setq: 'warn',
             redundant_quotes: 'warn',
@@ -66,6 +65,14 @@ exports.PRESETS = {
             shadow_builtin: 'warn',
             dynamic_doc: 'warn',
             redundant_if: 'warn',
+            unused_catch_result: 'warn',
+            string_concat_loop: 'warn',
+            if_without_else: 'warn',
+            redundant_list: 'warn',
+            entget_in_loop: 'warn',
+            promise_handler: 'warn',
+            module_cycle: 'warn',
+            arg_count_project: 'warn',
         },
     },
     strict: {
@@ -94,7 +101,6 @@ exports.PRESETS = {
             unused_let_binding: 'error',
             recursive_call: 'error',
             variable_shadow: 'error',
-            redundant_cond: 'error',
             unused_local_fun: 'error',
             multiple_setq: 'warn',
             redundant_quotes: 'error',
@@ -145,6 +151,14 @@ exports.PRESETS = {
             redundant_if: 'error',
             module_registration: 'error',
             namespace_header: 'error',
+            unused_catch_result: 'error',
+            string_concat_loop: 'warn',
+            if_without_else: 'error',
+            redundant_list: 'error',
+            entget_in_loop: 'warn',
+            promise_handler: 'error',
+            module_cycle: 'error',
+            arg_count_project: 'error',
         },
     },
     relaxed: {

package/dist/project.js

@@ -54,7 +54,7 @@ function collectDefuns(file) {
     }
     return results;
 }
-function collectReferences(file, _filepath) {
+function collectReferences(file) {
     const content = fs.readFileSync(file, 'utf-8');
     const ast = (0, parser_1.parseAst)(content);
     const results = [];
@@ -71,6 +71,93 @@ function collectReferences(file, _filepath) {
     }
     return results;
 }
+function countFunctionArgs(file) {
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    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) {
+        if (!node.children || node.children.length < 3)
+            continue;
+        const name = (0, parser_1.astIsSymbol)(node.children[1]) ? node.children[1].name : '';
+        if (!name)
+            continue;
+        const paramList = node.children[2];
+        if (paramList.type !== 'list' || !paramList.children) {
+            result.set(name, 0);
+            continue;
+        }
+        let count = 0;
+        for (const child of paramList.children) {
+            if (child.type === 'symbol' && child.name && child.name !== '/') {
+                count++;
+            }
+            else if (child.type === 'symbol' && child.name === '/') {
+                break;
+            }
+        }
+        result.set(name, count);
+    }
+    return result;
+}
+function countCallArgs(file) {
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const result = new Map();
+    const allCalls = (0, parser_1.astFindAll)(ast, n => {
+        if (n.type !== 'list' || !n.children || n.children.length === 0)
+            return false;
+        return (0, parser_1.astIsSymbol)(n.children[0]);
+    });
+    for (const call of allCalls) {
+        const name = call.children[0].name;
+        if (name === 'defun' || name === 'defun-q' || name.startsWith('c:') || name.includes(':'))
+            continue;
+        if (!result.has(name))
+            result.set(name, []);
+        const argCount = call.children ? call.children.length - 1 : 0;
+        result.get(name).push({ line: call.pos.line, count: argCount });
+    }
+    return result;
+}
+function findModuleDeps(filepath) {
+    const content = fs.readFileSync(filepath, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const imports = [];
+    const exports = [];
+    const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
+    for (const node of inPackageNodes) {
+        if (node.children && node.children.length >= 3 && node.children[1].type === 'symbol') {
+            const useList = node.children[2];
+            if (useList.type === 'list' && useList.children) {
+                for (const use of useList.children) {
+                    if (use.type === 'symbol' && use.name)
+                        imports.push(use.name);
+                }
+            }
+        }
+    }
+    const setqNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'setq'));
+    for (const node of setqNodes) {
+        if (node.children && node.children.length >= 3 &&
+            node.children[1].type === 'symbol' && node.children[1].name === '@::*modules*' &&
+            node.children[2].type === 'list' && node.children[2].children) {
+            for (const exp of node.children[2].children) {
+                if (exp.type === 'string' && typeof exp.value === 'string') {
+                    exports.push(exp.value);
+                }
+            }
+        }
+    }
+    return { imports, exports };
+}
+function collectAllModuleDeps(files) {
+    const deps = new Map();
+    for (const f of files) {
+        deps.set(f, findModuleDeps(f));
+    }
+    return deps;
+}
 function lintProject(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
@@ -85,6 +172,7 @@ function lintProject(files, config, rootDir) {
             continue;
         }
     }
+    // Build project symbol table
     for (const [filepath] of fileContents) {
         const defunList = collectDefuns(filepath);
         for (const d of defunList) {
@@ -92,17 +180,25 @@ function lintProject(files, config, rootDir) {
             list.push({ file: filepath, line: d.line });
             symbols.defuns.set(d.name, list);
         }
-        const refList = collectReferences(filepath, filepath);
+        const refList = collectReferences(filepath);
         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);
         }
     }
+    // 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));
+    }
     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);
             for (const iss of danglingIssues) {
@@ -134,6 +230,88 @@ 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 = [];
+            function 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}`,
+                            });
+                        }
+                    }
+                }
+            }
+        }
     }
     return allIssues;
 }

package/dist/rules.js

@@ -156,7 +156,6 @@ exports.RULES = [
         description: '检测函数调用自身（可能无限递归）',
         category: '正确性',
     },
-    { name: 'redundant_cond', defaultSeverity: 'warn', description: '检测单子句 cond 或末尾 T 子句', category: '风格' },
     { name: 'redundant_if', defaultSeverity: 'warn', description: '检测 if/when 分支中冗余 progn', category: '风格' },
     { name: 'redundant_let', defaultSeverity: 'warn', description: '检测无绑定的 let 建议改用 progn', category: '风格' },
     { name: 'redundant_nil_else', defaultSeverity: 'warn', description: '检测 if 中冗余的 nil 分支', category: '风格' },
@@ -229,6 +228,14 @@ exports.RULES = [
         description: '检测 vlax-* 使用前未调用 vl-load-com',
         category: '最佳实践',
     },
+    { name: 'unused_catch_result', defaultSeverity: 'warn', description: '检测 vl-catch-all-apply 结果被当布尔值用', category: '正确性' },
+    { name: 'string_concat_loop', defaultSeverity: 'warn', description: '检测循环内字符串拼接', category: '性能' },
+    { name: 'if_without_else', defaultSeverity: 'warn', description: '检测 if 无 else 分支且返回值被使用', category: '正确性' },
+    { name: 'redundant_list', defaultSeverity: 'warn', description: '检测 (list) 等价于 nil', category: '风格' },
+    { name: 'entget_in_loop', defaultSeverity: 'warn', description: '检测循环内 entget', category: '性能' },
+    { name: 'promise_handler', defaultSeverity: 'warn', description: '检测 vlax-invoke 缺少回调处理器', category: '最佳实践' },
+    { name: 'module_cycle', defaultSeverity: 'warn', description: '检测模块循环依赖', category: '架构' },
+    { name: 'arg_count_project', defaultSeverity: 'warn', description: '跨文件检查函数参数数量', category: '正确性' },
 ];
 function generateRulesMarkdown() {
     const lines = [

package/dist/runner.d.ts

@@ -1,7 +1,6 @@
 import { Issue, LintConfig } from './types';
 export declare function runChecks(content: string, file: string, config: LintConfig): Issue[];
-/** Single-pass visitor-based runChecks using AstVisitor */
-export declare function runChecksWithVisitor(content: string, file: string, config: LintConfig): Issue[];
+export declare function runChecksWithVisitorWrapper(content: string, file: string, config: LintConfig): Issue[];
 export declare function lintFiles(files: string[], config: LintConfig, rootDir: string): Issue[];
 export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
 export declare function applyFixes(issues: Issue[], content: string, filepath: string): string;