@atlisp/lint 0.1.15 → 0.1.17

package/atlisp-lint.default.json

@@ -63,7 +63,7 @@
     "cond_simplify": "warn",
     "quote_style": "warn",
     "eq_usage": "warn",
-    "lambda_syntax": "warn",
+    "lambda_syntax": "off",
     "comment_style": "warn",
     "empty_catch": "warn",
     "nth_usage": "warn",
@@ -79,7 +79,8 @@
     "dynamic_doc": "warn",
     "loop_optimization": "off",
     "type_check": "off",
-    "redundant_if": "warn"
+    "redundant_if": "warn",
+    "undeclared_setq": "warn"
   },
   "line_length": {
     "max": 100,
@@ -87,7 +88,7 @@
   },
   "function_complexity": {
     "max_lines": 60,
-    "max_nesting": 6
+    "max_nesting": 15
   },
   "cl_syntax": {
     "keywords": ["&key"]

package/dist/atlisp-lint.default.json

@@ -0,0 +1,90 @@
+{
+  "locale": "zh",
+  "source": {
+    "globs": ["**/*.lsp"],
+    "exclude": ["**/node_modules/**", "**/vendor/**", "**/.git/**"]
+  },
+  "checks": {
+    "parens": "error",
+    "encoding": "warn",
+    "cl_syntax": "warn",
+    "quit_exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn",
+    "vlax_without_loading": "off",
+    "token_in_url": "warn",
+    "open_without_close": "warn",
+    "bare_function_names": "off",
+    "line_length": "warn",
+    "function_complexity": "warn",
+    "parameter_naming": "warn",
+    "unused_variable": "warn",
+    "missing_doc": "warn",
+    "error_handling": "warn",
+    "global_naming": "warn",
+    "extra_parens": "warn",
+    "arg_count": "warn",
+    "strcat_usage": "warn",
+    "cond_simplify": "warn",
+    "redundant_progn": "warn",
+    "quote_style": "warn",
+    "eq_usage": "warn",
+    "lambda_syntax": "warn",
+    "comment_style": "warn",
+    "empty_catch": "warn",
+    "nth_usage": "warn",
+    "append_single": "warn",
+    "setq_multiple": "warn",
+    "function_order": "off",
+    "magic_number": "off",
+    "mixed_indent": "warn",
+    "long_function_call": "warn",
+    "no_return": "warn",
+    "shadow_builtin": "warn",
+    "dynamic_doc": "warn",
+    "loop_optimization": "off",
+    "type_check": "off",
+    "redundant_if": "warn",
+    "trailing_whitespace": "warn",
+    "module_registration": "off",
+    "namespace_header": "off"
+  },
+  "line_length": {
+    "max": 100,
+    "tab_width": 2
+  },
+  "function_complexity": {
+    "max_lines": 60,
+    "max_nesting": 6
+  },
+  "cl_syntax": {
+    "keywords": ["&key"]
+  },
+  "dangerous_calls": {
+    "quit": "error",
+    "exit": "error",
+    "command_shell": "error",
+    "startapp": "warn",
+    "vl_registry_write": "warn"
+  },
+  "module_registration": {
+    "severity": "off",
+    "patterns": [],
+    "dirs": ["modules"]
+  },
+  "namespace_header": {
+    "severity": "off",
+    "package": "",
+    "deps": [],
+    "search_lines": 15
+  },
+  "bare_function_names": {
+    "allowlist": ["T", "nil"],
+    "namespace_pattern": "^[a-z]+:"
+  },
+  "sbcl": {
+    "walk_exclude": [".vscode", "vendor", ".git"],
+    "defmacro_allow_files": ["compat-cl"]
+  }
+}

package/dist/checks/arg-count.js

@@ -2,119 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkArgCount = checkArgCount;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkArgCount(content, file) {
     const issues = [];
-    const lines = content.split('\n');
-    const defuns = [];
-    // Collect all defun definitions
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        const m = stripped.match(/\(defun\s+(\S+)\s+\(([^)]*)\)/);
-        if (m) {
-            const all = m[2];
-            const slashIdx = all.indexOf('/');
-            const paramStr = slashIdx >= 0 ? all.slice(0, slashIdx).trim() : all;
-            const params = paramStr.split(/\s+/).filter(Boolean);
-            defuns.push({ name: m[1], line: i + 1, paramCount: params.length });
-        }
-    }
-    // Check calls against definitions
-    for (const fn of defuns) {
-        if (fn.name.startsWith('c:') || fn.name.includes('/'))
+    const ast = (0, parser_1.parseAst)(content);
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        if (nameNode.type !== 'symbol' || !nameNode.name)
+            continue;
+        const funcName = nameNode.name;
+        // Skip C: commands and local functions
+        if (funcName.startsWith('c:') || funcName.startsWith('C:') || funcName.includes('/'))
             continue;
-        if (fn.paramCount === 0)
+        const paramList = defun.children[2];
+        if (paramList.type !== 'list' || !paramList.children)
+            continue;
+        // Count params before /
+        let paramCount = 0;
+        for (const p of paramList.children) {
+            if (p.type === 'symbol' && p.name === '/')
+                break;
+            if (p.type === 'symbol' && p.name && p.name !== 'T' && p.name !== 'nil') {
+                paramCount++;
+            }
+        }
+        if (paramCount === 0)
             continue;
-        for (let i = 0; i < lines.length; i++) {
-            const stripped = (0, utils_1.stripLine)(lines[i]);
-            const re = new RegExp('\\(\\s*' + fn.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s+');
-            // Don't match the definition line
-            if (stripped.includes('defun') && stripped.includes(fn.name))
+        // Find all calls to this function
+        const calls = (0, parser_1.astFindListWithHead)(ast, funcName);
+        for (const call of calls) {
+            if (!call.children || call.children.length === 0)
                 continue;
-            const callMatch = re.exec(stripped);
-            if (callMatch) {
-                // Collect all text from the call across lines
-                let callText = stripped.slice(callMatch.index);
-                let parenDepth = 0;
-                for (const ch of callText) {
-                    if (ch === '(')
-                        parenDepth++;
-                    else if (ch === ')')
-                        parenDepth--;
-                }
-                // If not closed on this line, read next lines
-                let lineIdx = i + 1;
-                while (parenDepth > 0 && lineIdx < lines.length) {
-                    const nextStripped = (0, utils_1.stripLine)(lines[lineIdx]);
-                    callText += ' ' + nextStripped;
-                    for (const ch of nextStripped) {
-                        if (ch === '(')
-                            parenDepth++;
-                        else if (ch === ')')
-                            parenDepth--;
-                    }
-                    lineIdx++;
-                }
-                // Extract args: remove the function call prefix
-                const afterName = callText.slice(callMatch[0].length - 1); // keep the leading (
-                // Find matching closing paren
-                let closeIdx = -1;
-                let pd = 1;
-                for (let j = 0; j < afterName.length; j++) {
-                    if (afterName[j] === '(')
-                        pd++;
-                    else if (afterName[j] === ')') {
-                        pd--;
-                        if (pd === 0) {
-                            closeIdx = j;
-                            break;
-                        }
-                    }
-                }
-                const argsStr = closeIdx >= 0 ? afterName.slice(0, closeIdx).trim() : afterName.trim();
-                if (!argsStr)
-                    continue;
-                // Count space-delimited args at depth 0
-                let argCount = 0;
-                let depth = 0;
-                let inArg = false;
-                for (const ch of argsStr) {
-                    if (ch === '(') {
-                        depth++;
-                        if (!inArg) {
-                            inArg = true;
-                        }
-                    }
-                    else if (ch === ')') {
-                        depth--;
-                        if (depth === 0) {
-                            if (inArg) {
-                                argCount++;
-                                inArg = false;
-                            }
-                        }
-                    }
-                    else if (depth === 0 && (ch === ' ' || ch === '\t')) {
-                        if (inArg) {
-                            argCount++;
-                            inArg = false;
-                        }
-                    }
-                    else if (!inArg) {
-                        inArg = true;
-                    }
-                }
-                if (inArg)
-                    argCount++;
-                if (argCount !== fn.paramCount) {
-                    issues.push({
-                        file,
-                        line: i + 1,
-                        severity: 'warn',
-                        rule: 'arg_count',
-                        message: (0, locale_1.t)('arg_count', fn.name, argCount, fn.paramCount),
-                    });
-                }
+            // Skip if the first child is the function name — that's the head of this call
+            const argCount = call.children.length - 1;
+            if (argCount !== paramCount) {
+                issues.push({
+                    file,
+                    line: call.pos.line,
+                    severity: 'warn',
+                    rule: 'arg_count',
+                    message: (0, locale_1.t)('arg_count', funcName, argCount, paramCount),
+                });
             }
         }
     }

package/dist/checks/bare-names.js

@@ -16,6 +16,8 @@ function checkBareFunctionNames(content, file, allowlist, namespacePattern) {
             continue;
         if (name.includes('/'))
             continue; // local: defun foo/bar
+        if (name.startsWith('cb-'))
+            continue; // DCL callback
         if (!nsRegex.test(name) && !name.includes(':')) {
             issues.push({
                 file,

package/dist/checks/global-naming.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkGlobalNaming = checkGlobalNaming;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
+/** Check if a variable name is earmuffed (*var*), optionally with a namespace prefix (ns:*var*) */
+function isEarmuffed(name) {
+    const localName = name.includes(':') ? name.slice(name.lastIndexOf(':') + 1) : name;
+    return localName.startsWith('*') && localName.endsWith('*') && localName.length > 2;
+}
 function isInsideLocalScope(node) {
     let cur = node.parent;
     while (cur) {
@@ -34,7 +39,7 @@ function checkGlobalNaming(content, file) {
                 continue;
             if (v.name === 'T' || v.name === 'nil')
                 continue;
-            if (v.name.startsWith('*') && v.name.endsWith('*'))
+            if (isEarmuffed(v.name))
                 continue;
             issues.push({
                 file,

package/dist/checks/index.js

@@ -44,6 +44,7 @@ const loop_optimization_1 = require("./loop-optimization");
 const type_check_1 = require("./type-check");
 const redundant_if_1 = require("./redundant-if");
 const trailing_ws_1 = require("./trailing-ws");
+const undeclared_setq_1 = require("./undeclared-setq");
 function runChecks(content, file, config) {
     const issues = [];
     const disableMap = (0, disable_1.parseDisableComments)(content);
@@ -108,6 +109,7 @@ function runChecks(content, file, config) {
         { rule: 'type_check', fn: () => (0, type_check_1.checkTypeCheck)(content, file) },
         { rule: 'redundant_if', fn: () => (0, redundant_if_1.checkRedundantIf)(content, file) },
         { rule: 'trailing_whitespace', fn: () => (0, trailing_ws_1.checkTrailingWhitespace)(content, file) },
+        { rule: 'undeclared_setq', fn: () => (0, undeclared_setq_1.checkUndeclaredSetq)(content, file) },
     ];
     for (const c of checks) {
         addIfEnabled(c.rule, c.fn);

package/dist/checks/no-return.js

@@ -2,48 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkNoReturn = checkNoReturn;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkNoReturn(content, file) {
     const issues = [];
-    const lines = content.split('\n');
-    let inDefun = false;
-    let defunName = '';
-    let defunStart = 0;
-    let depth = 0;
-    let hasReturn = false;
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]);
-        if (!inDefun) {
-            const m = stripped.match(/\(defun\s+(\S+)/);
-            if (m) {
-                inDefun = true;
-                defunName = m[1];
-                defunStart = i + 1;
-                depth = 0;
-                hasReturn = false;
-            }
-        }
-        if (inDefun) {
-            for (const ch of stripped) {
-                if (ch === '(')
-                    depth++;
-                else if (ch === ')')
-                    depth--;
-            }
-            if (stripped.trim().startsWith('(') && !stripped.includes('defun'))
-                hasReturn = true;
-            if (depth === 0 && defunName && !defunName.startsWith('c:')) {
-                if (!hasReturn) {
-                    issues.push({
-                        file,
-                        line: defunStart,
-                        severity: 'warn',
-                        rule: 'no_return',
-                        message: (0, locale_1.t)('no_return', defunName),
-                    });
-                }
-                inDefun = false;
-            }
+    const ast = (0, parser_1.parseAst)(content);
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        if (nameNode.type !== 'symbol' || !nameNode.name)
+            continue;
+        const funcName = nameNode.name;
+        // Skip C: commands — they don't need return values
+        if (/^[cC]:/.test(funcName))
+            continue;
+        // Body starts at index 3 (defun, name, params, body...)
+        const bodyExprs = defun.children.slice(3);
+        if (bodyExprs.length === 0) {
+            issues.push({
+                file,
+                line: defun.pos.line,
+                severity: 'warn',
+                rule: 'no_return',
+                message: (0, locale_1.t)('no_return', funcName),
+            });
         }
     }
     return issues;

package/dist/checks/recursive-call.js

@@ -8,6 +8,8 @@ function checkRecursiveCall(content, file) {
     const ast = (0, parser_1.parseAst)(content);
     return checkRecursiveCallAst(ast, file);
 }
+/** Forms that provide conditional branching (exit condition for recursion) */
+const CONDITIONAL_FORMS = new Set(['if', 'cond', 'when', 'unless']);
 function checkRecursiveCallAst(ast, file) {
     const issues = [];
     const defuns = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'defun'));
@@ -18,25 +20,30 @@ function checkRecursiveCallAst(ast, file) {
         const funcName = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '';
         if (!funcName)
             continue;
-        // Walk the function body (skip name and param list)
+        // Check body for self-call (skip name and param list)
+        let hasRecursiveCall = false;
+        let hasConditional = false;
         for (let i = 3; i < defun.children.length; i++) {
-            if (hasSelfCall(defun.children[i], funcName)) {
-                issues.push({
-                    file,
-                    line: defun.pos.line,
-                    severity: 'warn',
-                    rule: 'recursive_call',
-                    message: (0, locale_1.t)('recursive_call', funcName),
-                });
-                break; // one issue per function
-            }
+            if (hasSelfCall(defun.children[i], funcName))
+                hasRecursiveCall = true;
+            if (hasConditionalForm(defun.children[i]))
+                hasConditional = true;
+        }
+        // Only warn if the function calls itself AND has no exit condition
+        if (hasRecursiveCall && !hasConditional) {
+            issues.push({
+                file,
+                line: defun.pos.line,
+                severity: 'warn',
+                rule: 'recursive_call',
+                message: (0, locale_1.t)('recursive_call', funcName),
+            });
         }
     }
     return issues;
 }
 function hasSelfCall(node, funcName) {
     for (const n of (0, parser_1.astWalk)(node)) {
-        // Check if this node is a list whose car is the function name
         if (n.type === 'list' && n.children && n.children.length > 0) {
             const car = n.children[0];
             if (car.type === 'symbol' && car.name === funcName) {
@@ -46,4 +53,15 @@ function hasSelfCall(node, funcName) {
     }
     return false;
 }
+function hasConditionalForm(node) {
+    for (const n of (0, parser_1.astWalk)(node)) {
+        if (n.type === 'list' && n.children && n.children.length > 0) {
+            const car = n.children[0];
+            if (car.type === 'symbol' && car.name && CONDITIONAL_FORMS.has(car.name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 //# sourceMappingURL=recursive-call.js.map

package/dist/checks/undeclared-setq.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkUndeclaredSetq(content: string, file: string): Issue[];
+//# sourceMappingURL=undeclared-setq.d.ts.map

package/dist/checks/undeclared-setq.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUndeclaredSetq = checkUndeclaredSetq;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+/** Extract declared variable names from a defun's parameter list (both sides of /) */
+function getDeclaredVars(defun) {
+    const vars = new Set();
+    if (!defun.children || defun.children.length < 3)
+        return vars;
+    const paramList = defun.children[2];
+    if (paramList.type !== 'list' || !paramList.children)
+        return vars;
+    for (const p of paramList.children) {
+        if (p.type === 'symbol' && p.name && p.name !== '/' && p.name !== 'T' && p.name !== 'nil') {
+            vars.add(p.name);
+        }
+    }
+    return vars;
+}
+/** Check if a variable name is earmuffed (*var*), optionally with a namespace prefix (ns:*var*) */
+function isEarmuffed(name) {
+    const localName = name.includes(':') ? name.slice(name.lastIndexOf(':') + 1) : name;
+    return localName.startsWith('*') && localName.endsWith('*') && localName.length > 2;
+}
+/** Find the nearest enclosing defun that is not inside a nested lambda/defun */
+function findEnclosingDefun(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'list' && cur.children && cur.children.length > 0) {
+            const head = cur.children[0];
+            if (head.type === 'symbol') {
+                if (head.name === 'defun')
+                    return cur;
+                if (head.name === 'lambda')
+                    return null; // stopped by lambda boundary
+            }
+        }
+        cur = cur.parent;
+    }
+    return null;
+}
+function checkUndeclaredSetq(content, file) {
+    const issues = [];
+    const ast = (0, parser_1.parseAst)(content);
+    const setqForms = (0, parser_1.astFindListWithHead)(ast, 'setq');
+    for (const setq of setqForms) {
+        if (!setq.children || setq.children.length < 2)
+            continue;
+        // Skip top-level setq (not inside any defun)
+        const defun = findEnclosingDefun(setq);
+        if (!defun)
+            continue;
+        const declared = getDeclaredVars(defun);
+        for (let i = 1; i < setq.children.length; i += 2) {
+            const v = setq.children[i];
+            if (v.type !== 'symbol' || !v.name)
+                continue;
+            if (v.name === 'T' || v.name === 'nil')
+                continue;
+            if (isEarmuffed(v.name))
+                continue;
+            if (declared.has(v.name))
+                continue;
+            issues.push({
+                file,
+                line: v.pos.line,
+                severity: 'warn',
+                rule: 'undeclared_setq',
+                message: (0, locale_1.t)('undeclared_setq', v.name),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=undeclared-setq.js.map

package/dist/config.js

@@ -64,6 +64,7 @@ const DEFAULT_CONFIG = {
         unused_variable: 'warn',
         missing_doc: 'warn',
         trailing_whitespace: 'warn',
+        undeclared_setq: 'warn',
         module_registration: 'off',
         namespace_header: 'off',
         unused_parameter: 'warn',
@@ -105,7 +106,7 @@ const DEFAULT_CONFIG = {
         cond_simplify: 'warn',
         quote_style: 'warn',
         eq_usage: 'warn',
-        lambda_syntax: 'warn',
+        lambda_syntax: 'off',
         comment_style: 'warn',
         empty_catch: 'warn',
         nth_usage: 'warn',
@@ -129,7 +130,7 @@ const DEFAULT_CONFIG = {
     },
     function_complexity: {
         max_lines: 60,
-        max_nesting: 6,
+        max_nesting: 15,
     },
     cl_syntax: {
         keywords: ['&key'],

package/dist/lib/lint-sbcl.lisp

@@ -0,0 +1,161 @@
+;; @lisp SBCL Lint — syntax validation via SBCL
+;; Usage: sbcl --script lint-sbcl.lisp <src-dir> <stub-packages.json> <walk-exclude-json> <defmacro-allow-files-json> <locale>
+
+(require :uiop)
+
+(defparameter *errors* 0)
+(defparameter *warnings* 0)
+(defparameter *checked* 0)
+(defparameter *locale* "zh")
+
+;; ── i18n ──────────────────────────────────────────────────────────────
+(defun i18n (key)
+  (cdr (assoc key
+    (if (string= *locale* "zh")
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))))))
+
+;; ── Stub packages from external file ──────────────────────────────────
+(defun load-stub-packages (file-path)
+  (flet ((ensure-pkg (name &optional use-list)
+           (unless (find-package name)
+             (make-package name :use (or use-list '())))))
+    (with-open-file (s file-path :direction :input)
+      (let ((packages (read s)))
+        (dolist (pkg packages)
+          (ensure-pkg (first pkg) (second pkg)))))))
+
+;; ── File walking ──────────────────────────────────────────────────────
+(defun source-files (dir)
+  (sort
+    (remove-if-not
+      (lambda (p)
+        (let ((n (pathname-type p)))
+          (and n (string-equal n "lsp"))))
+      (uiop:directory-files dir))
+    'string< :key #'namestring))
+
+(defun walk-tree (dir exclude-dirs)
+  (let ((result (source-files dir)))
+    (dolist (sub (uiop:subdirectories dir))
+      (let ((name (car (last (pathname-directory sub)))))
+        (unless (find name exclude-dirs :test 'string=)
+          (setf result (append result (walk-tree sub exclude-dirs))))))
+    result))
+
+;; ── Per-file check ────────────────────────────────────────────────────
+(defun check-file (path src-dir defmacro-allow-files)
+  (incf *checked*)
+  (let* ((rel (enough-namestring path src-dir))
+         (fullname (format nil "~a.~a" (pathname-name path) (pathname-type path))))
+    (format t "  ~a ... " rel)
+    (force-output)
+    ;; Syntax check via READ
+    (handler-case
+        (with-open-file (s path :direction :input)
+          (loop for form = (read s nil :eof)
+                until (eq form :eof)))
+      (error (e)
+        (let ((msg (princ-to-string e)))
+          (cond
+            ((search "not found" msg)
+             (format t "~%  [NOTE] ~a: ~a~%" rel (i18n :not-found))
+             (incf *warnings*))
+            (t
+             (format t "~a~%  [ERROR] ~a: ~a~%" (i18n :fail) rel (i18n :syntax-error))
+             (incf *errors*)
+             (return-from check-file))))))
+    ;; Trailing whitespace
+    (with-open-file (s path :direction :input)
+      (loop for line = (read-line s nil nil)
+            for lineno from 1
+            while line
+            when (and (> (length line) 0)
+                      (find (char line (1- (length line))) '(#\Space #\Tab)))
+              do (progn
+                   (format t "~%  [WARN] ~a line ~d: ~a~%" rel lineno (i18n :trailing-ws))
+                   (incf *warnings*))))
+    ;; CL-ism checks: raw content scan
+    (with-open-file (s path :direction :input)
+      (let ((content (make-string (file-length s))))
+        (file-position s 0)
+        (read-sequence content s)
+        (when (search "#(" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :vec-syntax))
+          (incf *warnings*))
+        (when (search "#\\" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :char-syntax))
+          (incf *warnings*))
+        (when (search "#." content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :eval-syntax))
+          (incf *warnings*))
+        (when (and (search "defmacro" content)
+                   (not (some (lambda (s) (search s fullname)) defmacro-allow-files)))
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :defmacro))
+          (incf *warnings*))))
+    (format t "~a~%" (i18n :ok))))
+
+;; ── Main ──────────────────────────────────────────────────────────────
+(defun main ()
+  (let* ((args (uiop:command-line-arguments))
+         (src-dir (first args))
+         (stub-file (second args))
+         (walk-exclude (if (third args)
+                          (read-from-string (third args))
+                          '(".vscode" "test" "experiment" "tools" ".git")))
+         (defmacro-allow (if (fourth args)
+                            (read-from-string (fourth args))
+                            '("compat-cl")))
+         (locale (fifth args)))
+    (when locale (setf *locale* locale))
+    (load-stub-packages stub-file)
+
+    (format t "~%==================================================~%")
+    (format t "~a~%" (i18n :header))
+    (format t "~a: ~a~%" (i18n :source) (namestring (pathname src-dir)))
+    (format t "==================================================~%~%")
+    (setf *errors* 0 *warnings* 0 *checked* 0)
+
+    (let ((files (walk-tree src-dir walk-exclude)))
+      (format t "~a~%~%" (format nil (i18n :found) (length files)))
+      (dolist (f files)
+        (check-file f src-dir defmacro-allow)))
+
+    (format t "~%==================================================~%")
+    (format t "~a: ~d~%" (i18n :scanned) *checked*)
+    (format t "~a: ~d~%" (i18n :errors) *errors*)
+    (format t "~a: ~d~%" (i18n :warnings) *warnings*)
+    (format t "==================================================~%~%")
+    (if (> *errors* 0)
+        (uiop:quit 1)
+        (uiop:quit 0))))
+
+(main)

package/dist/locale.js

@@ -18,11 +18,13 @@ const messages = {
         vlax_without_loading: 'vlax-* call without vl-load-com in file',
         token_in_url: 'Possible token exposure in string: token= in URL',
         open_without_close: 'File has {0} open() calls but {1} close() calls (possible resource leak)',
+        arg_count: "Function '{0}' called with {1} arguments but defined with {2}",
         bare_function_names: "Unnamespaced function '{0}' (missing @:: or C: prefix)",
         module_registration: 'Module file missing @::*modules* registration (expected in last lines)',
         'namespace_header.missing': 'Missing (in-package {0}) header',
         'namespace_header.wrong': 'in-package target is not {0}',
         trailing_whitespace: 'Trailing whitespace',
+        undeclared_setq: "Variable '{0}' is setq'd inside defun but not declared in the parameter list — add to / list",
         line_length: 'Line length {0} exceeds {1} characters',
         'function_complexity.lines': "Function '{0}' has {1} lines (max {2})",
         'function_complexity.nesting': "Function '{0}' nesting depth {1} exceeds {2}",
@@ -64,6 +66,7 @@ const messages = {
         duplicate_defun: "Function '{0}' is defined multiple times",
         dangling_defun: "Function '{0}' is defined but never called",
         missing_export: "Function '{0}' is not registered in @::*modules*",
+        no_return: "Function '{0}' has no return value (body is empty)",
         unused_package_dep: "Imported package '{0}' is never referenced",
         'runner.read_error': 'Cannot read file',
         'sbcl.script_not_found': 'lint-sbcl.lisp not found at {0}',
@@ -127,11 +130,13 @@ Options:
         vlax_without_loading: '文件中使用了 vlax-* 函数但未调用 vl-load-com',
         token_in_url: '字符串中可能泄露令牌：URL 中包含 token=',
         open_without_close: '文件中有 {0} 个 open() 调用，但只有 {1} 个 close() 调用（可能存在资源泄露）',
+        arg_count: "函数 '{0}' 调用时传入了 {1} 个参数，但定义时为 {2} 个",
         bare_function_names: "函数 '{0}' 缺少命名空间前缀（缺少 @:: 或 C: 前缀）",
         module_registration: '模块文件缺少 @::*modules* 注册（应在文件末尾附近）',
         'namespace_header.missing': '缺少 (in-package {0}) 头',
         'namespace_header.wrong': 'in-package 目标不是 {0}',
         trailing_whitespace: '行尾有多余空格',
+        undeclared_setq: "变量 '{0}' 在 defun 内被 setq 但未声明到参数表中——建议加入 / 私有变量表",
         line_length: '行长度 {0} 超过 {1} 个字符',
         'function_complexity.lines': "函数 '{0}' 有 {1} 行（最大 {2} 行）",
         'function_complexity.nesting': "函数 '{0}' 嵌套深度 {1} 超过 {2}",
@@ -173,6 +178,7 @@ Options:
         duplicate_defun: "函数 '{0}' 被多次定义",
         dangling_defun: "函数 '{0}' 定义了但从未被调用",
         missing_export: "函数 '{0}' 未注册到 @::*modules*",
+        no_return: "函数 '{0}' 没有表达式——函数体为空",
         unused_package_dep: "导入的包 '{0}' 从未被引用",
         'runner.read_error': '无法读取文件',
         'sbcl.script_not_found': '未找到 lint-sbcl.lisp：{0}',

package/dist/presets.js

@@ -54,7 +54,7 @@ exports.PRESETS = {
             cond_simplify: 'warn',
             quote_style: 'warn',
             eq_usage: 'warn',
-            lambda_syntax: 'warn',
+            lambda_syntax: 'off',
             comment_style: 'warn',
             empty_catch: 'warn',
             nth_usage: 'warn',

package/dist/rules.js

@@ -92,7 +92,7 @@ exports.RULES = [
     { name: 'global_naming', defaultSeverity: 'warn', description: '检测全局变量是否使用 *...* 命名', category: '风格' },
     {
         name: 'lambda_syntax',
-        defaultSeverity: 'warn',
+        defaultSeverity: 'off',
         description: '检测 (function (lambda ...)) 建议使用缩写',
         category: '风格',
     },
@@ -189,6 +189,12 @@ exports.RULES = [
     { name: 'trailing_paren', defaultSeverity: 'warn', description: '检测多余闭合括号', category: '语法' },
     { name: 'trailing_whitespace', defaultSeverity: 'warn', description: '检测行尾多余空格', category: '风格' },
     { name: 'type_check', defaultSeverity: 'off', description: '检测 getvar 结果未做类型检查', category: '最佳实践' },
+    {
+        name: 'undeclared_setq',
+        defaultSeverity: 'warn',
+        description: '检测 defun 内 setq 了未声明的变量（建议加入 / 私有变量表）',
+        category: '正确性',
+    },
     {
         name: 'unused_let_binding',
         defaultSeverity: 'warn',

package/dist/runner.js

@@ -111,6 +111,7 @@ const dynamic_doc_1 = require("./checks/dynamic-doc");
 const loop_optimization_1 = require("./checks/loop-optimization");
 const type_check_1 = require("./checks/type-check");
 const redundant_if_1 = require("./checks/redundant-if");
+const undeclared_setq_1 = require("./checks/undeclared-setq");
 const format_indent_1 = require("./checks/format-indent");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
@@ -235,6 +236,7 @@ function runChecks(content, file, config) {
     addIfEnabled('loop_optimization', () => (0, loop_optimization_1.checkLoopOptimization)(content, file));
     addIfEnabled('type_check', () => (0, type_check_1.checkTypeCheck)(content, file));
     addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
+    addIfEnabled('undeclared_setq', () => (0, undeclared_setq_1.checkUndeclaredSetq)(content, file));
     addIfEnabled('format_indent', () => (0, format_indent_1.checkFormatIndent)(content, file, config.line_length.tab_width));
     return issues;
 }

package/dist/stub-packages.json

@@ -0,0 +1,41 @@
+((AUTOLISP ())
+ (@ (COMMON-LISP AUTOLISP))
+ (C ())
+ (JSON ())
+ (SIDEBAR ())
+ (FUN ())
+ (DCL ())
+ (BASE ())
+ (STRING ())
+ (BLOCK ())
+ (ENTITY ())
+ (LAYER ())
+ (LAYOUT ())
+ (CURVE ())
+ (LIST ())
+ (M ())
+ (P ())
+ (UI ())
+ (SYS ())
+ (EXCEL ())
+ (WORD ())
+ (RE ())
+ (VECTRA ())
+ (DOS ())
+ (AT-PM ())
+ (QRENCODE ())
+ (NETWORK ())
+ (PKGMAN ())
+ (DATETIME ())
+ (DICT ())
+ (@NLP ())
+ (AT-SIDEBAR ())
+ (S ())
+ (VL ())
+ (VLR ())
+ (VLAX ())
+ (THEME ())
+ (AJAX ())
+ (ATLISP ())
+ (LOG ())
+ (ATLISP-CORE ()))

package/dist/validate.js

@@ -68,6 +68,7 @@ const VALID_RULES = [
     'trailing_paren',
     'trailing_whitespace',
     'type_check',
+    'undeclared_setq',
     'unused_let_binding',
     'unused_local_fun',
     'unused_package_dep',

package/package.json

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