@atlisp/lint 0.2.7 → 0.2.9

package/atlisp-lint.default.json

@@ -87,7 +87,10 @@
     "entget_in_loop": "warn",
     "promise_handler": "off",
     "module_cycle": "warn",
-    "arg_count_project": "warn"
+    "arg_count_project": "warn",
+    "redundant_entmake": "warn",
+    "missing_princ": "warn",
+    "global_function_naming": "info"
   },
   "line_length": {
     "max": 200,

package/atlisp-lint.schema.json

@@ -0,0 +1,200 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "@atlisp/lint configuration",
+  "description": "Configuration schema for @atlisp/lint — AutoLISP static analysis tool",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "description": "Path to this schema file"
+    },
+    "locale": {
+      "type": "string",
+      "enum": ["zh", "en"],
+      "default": "zh",
+      "description": "Output language (zh=Chinese, en=English)"
+    },
+    "preset": {
+      "type": "string",
+      "enum": ["recommended", "strict", "relaxed"],
+      "description": "Config preset to start from (applied before user overrides)"
+    },
+    "source": {
+      "type": "object",
+      "properties": {
+        "globs": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["**/*.lsp"],
+          "description": "Glob patterns to match AutoLISP source files"
+        },
+        "exclude": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["**/node_modules/**", "**/vendor/**", "**/.git/**"],
+          "description": "Glob patterns to exclude from linting"
+        }
+      },
+      "required": ["globs", "exclude"]
+    },
+    "checks": {
+      "type": "object",
+      "description": "Rule severity configuration",
+      "properties": {
+        "append_single": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "arg_count": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "arg_count_project": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "assoc_without_cdr": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "bare_function_names": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "builtin_arg_count": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "cl_syntax": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "command_shell": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "comment_style": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "commented_code": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "cond_duplicate": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "cond_simplify": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "constant_condition": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "dangling_defun": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "double_not": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "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_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" },
+        "eq_usage": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "error_handling": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "extra_parens": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "format_indent": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "function_complexity": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "function_order": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "global_function_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "global_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "identical_branches": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "if_without_else": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "lambda_syntax": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "line_length": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "long_function_call": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "loop_optimization": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "magic_number": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "misplaced_else": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "missing_doc": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "missing_export": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "missing_princ": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "mixed_indent": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "module_cycle": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "module_registration": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "multiple_setq": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "namespace_header": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "no_return": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "nth_usage": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "open_without_close": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "parameter_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "parens": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "promise_handler": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "quit_exit": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "quote_style": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "quote_vs_function": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "recursive_call": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "redundant_entmake": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "redundant_if": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_let": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_list": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_nil_else": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_progn": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_quotes": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_setq": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "self_compare": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "setq_multiple": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "setq_single_arg": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "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_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" },
+        "trailing_paren": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "trailing_whitespace": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "undeclared_setq": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "unused_catch_result": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "unused_let_binding": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "unused_local_fun": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "unused_package_dep": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "unused_parameter": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "unused_variable": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "variable_shadow": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "vl_registry_write": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "vlax_without_loading": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "while_constant": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" }
+      },
+      "additionalProperties": false
+    },
+    "line_length": {
+      "type": "object",
+      "properties": {
+        "max": { "type": "integer", "minimum": 1, "default": 200 },
+        "tab_width": { "type": "integer", "minimum": 1, "default": 2 }
+      },
+      "required": ["max", "tab_width"]
+    },
+    "function_complexity": {
+      "type": "object",
+      "properties": {
+        "max_lines": { "type": "integer", "minimum": 1, "default": 300 },
+        "max_nesting": { "type": "integer", "minimum": 1, "default": 30 }
+      }
+    },
+    "cl_syntax": {
+      "type": "object",
+      "properties": {
+        "keywords": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["&key"]
+        }
+      }
+    },
+    "dangerous_calls": {
+      "type": "object",
+      "properties": {
+        "quit": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "exit": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "command_shell": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "startapp": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "vl_registry_write": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" }
+      }
+    },
+    "module_registration": {
+      "type": "object",
+      "properties": {
+        "severity": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "patterns": { "type": "array", "items": { "type": "string" } },
+        "dirs": { "type": "array", "items": { "type": "string" }, "default": ["modules"] }
+      }
+    },
+    "namespace_header": {
+      "type": "object",
+      "properties": {
+        "severity": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "package": { "type": "string", "default": "" },
+        "deps": { "type": "array", "items": { "type": "string" } },
+        "search_lines": { "type": "integer", "minimum": 1, "default": 15 }
+      }
+    },
+    "bare_function_names": {
+      "type": "object",
+      "properties": {
+        "allowlist": { "type": "array", "items": { "type": "string" }, "default": ["T", "nil"] },
+        "namespace_pattern": { "type": "string", "default": "^[a-z]+:" }
+      }
+    },
+    "sbcl": {
+      "type": "object",
+      "properties": {
+        "walk_exclude": { "type": "array", "items": { "type": "string" }, "default": [".vscode", "vendor", ".git"] },
+        "defmacro_allow_files": { "type": "array", "items": { "type": "string" }, "default": ["compat-cl"] }
+      }
+    }
+  }
+}

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/global-function-naming.d.ts

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

package/dist/checks/global-function-naming.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGlobalFunctionNaming = checkGlobalFunctionNaming;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+const BUILTIN_FUNCTIONS = new Set([
+    'if', 'cond', 'when', 'unless', 'progn', 'setq', 'setq-e', 'while', 'repeat',
+    'foreach', 'lambda', 'function', 'quote', 'defun', 'defun-q', 'defmacro',
+    'let', 'let*', 'mapcar', 'apply', 'eval', 'load', 'require',
+    'car', 'cdr', 'cadr', 'cdar', 'caar', 'cddr', 'caddr', 'cadar',
+    'cons', 'list', 'append', 'reverse', 'nth', 'assoc', 'subst', 'member',
+    'length', 'numberp', 'stringp', 'listp', 'atom', 'null', 'not',
+    'eq', 'equal', '=', '/=', '<', '>', '<=', '>=',
+    '+', '-', '*', '/', '1+', '1-', 'abs', 'min', 'max',
+    'strcat', 'substr', 'strlen', 'strcase',
+    'itoa', 'atoi', 'rtos', 'atof', 'fix', 'float',
+    'princ', 'print', 'prin1', 'prompt', 'terpri',
+    'open', 'close', 'read-line', 'write-line', 'read-char', 'write-char',
+    'entmake', 'entmakex', 'entget', 'entmod', 'entdel', 'entlast', 'entnext',
+    'ssget', 'ssadd', 'ssdel', 'sslength', 'ssname', 'ssmemb',
+    'command', 'vl-cmdf', 'vlax-invoke', 'vlax-invoke-method',
+    'vlax-get', 'vlax-put', 'vlax-get-property', 'vlax-put-property',
+    'vlax-make-variant', 'vlax-variant-value',
+    'vlax-safearray', 'vlax-safearray-fill', 'vlax-safearray->list',
+    'vl-catch-all-apply', 'vl-catch-all-error-p', 'vl-catch-all-error-message',
+    'vl-load-com', 'vlax-dump-object', 'vlax-for',
+    'vl-registry-read', 'vl-registry-write', 'vl-registry-delete',
+    'vl-file-copy', 'vl-file-delete', 'vl-file-rename',
+    'vl-directory-files', 'vl-mkdir', 'vl-string->list', 'vl-list->string',
+    'vl-string-search', 'vl-string-subst',
+    'vl-string-position', 'vl-string-mismatch',
+    'vl-symbol-value', 'vl-symbol-name',
+    'vl-sort', 'vl-sort-i',
+    'vl-remove-if', 'vl-remove-if-not', 'vl-member-if', 'vl-some', 'vl-every',
+    'vl-position', 'vl-consp',
+    'startapp', 'quit', 'exit', '*error*',
+    'vla-get-', 'vla-put-', 'vlax-ename->vla-object', 'vlax-vla-object->ename',
+    'vlax-3d-point', 'vlax-tmatrix',
+    'vlax-curve-getarea', 'vlax-curve-getdistatparam', 'vlax-curve-getparamatdist',
+    'vlax-curve-getclosestpointto', 'vlax-curve-getstartpoint', 'vlax-curve-getendpoint',
+    'vlax-curve-getpointatdist', 'vlax-curve-getpointatparam',
+]);
+function checkGlobalFunctionNaming(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]).trim();
+        const m = stripped.match(/^\s*\(\s*defun\s+([^\s(]+)/);
+        if (!m)
+            continue;
+        const fnName = m[1];
+        if (BUILTIN_FUNCTIONS.has(fnName))
+            continue;
+        if (fnName.startsWith('C:') || fnName.startsWith('c:'))
+            continue;
+        if (fnName.includes(':'))
+            continue;
+        issues.push({
+            file,
+            line: i + 1,
+            severity: 'info',
+            rule: 'global_function_naming',
+            message: (0, locale_1.t)('global_function_naming', fnName),
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=global-function-naming.js.map

package/dist/checks/missing-princ.d.ts

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

package/dist/checks/missing-princ.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMissingPrinc = checkMissingPrinc;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkMissingPrinc(content, file) {
+    const issues = [];
+    let ast;
+    try {
+        ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    }
+    catch {
+        return issues;
+    }
+    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 nameNode = node.children[1];
+        if (!(0, parser_1.astIsSymbol)(nameNode))
+            continue;
+        const name = nameNode.name || '';
+        if (!name.startsWith('C:') && !name.startsWith('c:'))
+            continue;
+        const body = node.children.slice(3);
+        if (body.length === 0)
+            continue;
+        const lastForm = body[body.length - 1];
+        const isPrincCall = (lastForm.type === 'list' &&
+            lastForm.children &&
+            lastForm.children.length > 0 &&
+            (0, parser_1.astIsSymbol)(lastForm.children[0]) &&
+            ['princ', 'print', 'prin1'].includes(lastForm.children[0].name || ''));
+        if (!isPrincCall) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'missing_princ',
+                message: (0, locale_1.t)('missing_princ', name),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=missing-princ.js.map

package/dist/checks/redundant-entmake.d.ts

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

package/dist/checks/redundant-entmake.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantEntmake = checkRedundantEntmake;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkRedundantEntmake(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        if (/\((?:entmake|entmakex)\s+\(list\s+/.test(stripped)) {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'redundant_entmake',
+                message: (0, locale_1.t)('redundant_entmake'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-entmake.js.map

package/dist/config.js

@@ -120,7 +120,7 @@ const DEFAULT_CONFIG = {
         shadow_builtin: 'warn',
         dynamic_doc: 'warn',
         loop_optimization: 'info',
-        format_indent: 'off',
+        format_indent: 'warn',
         redundant_if: 'info',
         unused_catch_result: 'info',
         string_concat_loop: 'info',
@@ -130,6 +130,9 @@ const DEFAULT_CONFIG = {
         promise_handler: 'off',
         module_cycle: 'warn',
         arg_count_project: 'warn',
+        redundant_entmake: 'warn',
+        missing_princ: 'warn',
+        global_function_naming: 'info',
     },
     line_length: {
         max: 200,

package/dist/formatter.d.ts

@@ -1,2 +1,3 @@
 export declare function formatCode(content: string, indentSize?: number): string;
+export declare function formatCodeStable(content: string, indentSize?: number): string;
 //# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.js

@@ -1,51 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCode = formatCode;
+exports.formatCodeStable = formatCodeStable;
 const utils_1 = require("./utils");
-function v1Format(content, indentSize) {
+function isCommentLine(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith(';') || trimmed.startsWith(';|');
+}
+function formatCode(content, indentSize = 2) {
+    if (content === '' || content === '\n')
+        return content;
     const lines = content.split('\n');
     const result = [];
     let depth = 0;
-    for (const line of lines) {
-        const trimmedLine = line.trimEnd();
-        if (trimmedLine === '') {
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const rawLine = lines[lineIdx];
+        const trimmed = rawLine.trimEnd();
+        if (trimmed === '') {
             result.push('');
             continue;
         }
-        const stripped = (0, utils_1.stripLine)(trimmedLine);
+        const isComment = isCommentLine(trimmed);
+        const stripped = (0, utils_1.stripLine)(trimmed);
         const trimmedStripped = stripped.trim();
+        if (trimmedStripped === '' && isComment) {
+            result.push(' '.repeat(depth * indentSize) + trimmed.trimStart());
+            continue;
+        }
         if (trimmedStripped === '') {
-            const indent = ' '.repeat(depth * indentSize);
-            result.push(indent + trimmedLine.trimStart());
+            result.push(' '.repeat(depth * indentSize) + trimmed.trimStart());
             continue;
         }
-        let openCount = 0;
-        let closeCount = 0;
+        const opens = (trimmedStripped.match(/\(/g) || []).length;
+        const closes = (trimmedStripped.match(/\)/g) || []).length;
+        let leadingCloseCount = 0;
         for (const ch of trimmedStripped) {
-            if (ch === '(')
-                openCount++;
-            else if (ch === ')')
-                closeCount++;
+            if (ch === ')')
+                leadingCloseCount++;
+            else
+                break;
         }
         let effectiveDepth = depth;
-        if (trimmedStripped.startsWith(')')) {
-            let leadingClose = 0;
-            for (const ch of trimmedStripped) {
-                if (ch === ')')
-                    leadingClose++;
-                else
-                    break;
-            }
-            effectiveDepth = Math.max(0, depth - leadingClose);
+        if (leadingCloseCount > 0) {
+            effectiveDepth = Math.max(0, depth - leadingCloseCount);
         }
-        result.push(' '.repeat(effectiveDepth * indentSize) + trimmedLine.trimStart());
-        depth += openCount - closeCount;
+        const indent = ' '.repeat(effectiveDepth * indentSize);
+        result.push(indent + trimmed.trimStart());
+        depth += opens - closes;
         if (depth < 0)
             depth = 0;
     }
-    return result;
+    let output = result.join('\n');
+    if (output.length > 0 && !output.endsWith('\n')) {
+        output += '\n';
+    }
+    return output;
 }
-function formatCode(content, indentSize = 2) {
-    return v1Format(content, indentSize).join('\n');
+function formatCodeStable(content, indentSize = 2) {
+    const first = formatCode(content, indentSize);
+    const second = formatCode(first, indentSize);
+    return second;
 }
 //# sourceMappingURL=formatter.js.map

package/dist/index.js

@@ -46,6 +46,7 @@ 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 rules_1 = require("./rules");
 const cache_1 = require("./cache");
 const watch_1 = require("./watch");
 function parseArgs() {
@@ -71,6 +72,7 @@ function parseArgs() {
         formatCode: false,
         formatCheck: false,
         sbcl: false,
+        docs: false,
     };
     for (let i = 0; i < argv.length; i++) {
         switch (argv[i]) {
@@ -137,6 +139,9 @@ function parseArgs() {
             case '--sbcl':
                 opts.sbcl = true;
                 break;
+            case '--docs':
+                opts.docs = true;
+                break;
             default:
                 break;
         }
@@ -297,6 +302,12 @@ async function main() {
         const configPath = opts.config || path.join(rootDir, 'atlisp-lint.json');
         const config = (0, config_1.loadConfig)(fs.existsSync(configPath) ? configPath : undefined);
         (0, locale_1.setLocale)(config.locale || 'zh');
+        if (opts.docs) {
+            console.log((0, rules_1.generateRulesMarkdown)());
+            console.log();
+            console.log((0, rules_1.generateSchemaHint)());
+            return;
+        }
         if (opts.help) {
             printHelp();
             return;

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

@@ -101,6 +101,9 @@ const messages = {
         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)",
+        redundant_entmake: '(entmake (list (cons ...))) should use quoted association list for performance',
+        missing_princ: "C: command '{0}' is missing trailing (princ) — may return nil to the command line",
+        global_function_naming: "Function '{0}' lacks a package prefix — consider using namespace: prefix",
         'help.text': `@atlisp/lint - AutoLISP static analysis tool
 
 Usage: atlisp-lint [options]
@@ -126,7 +129,8 @@ Options:
   --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)`,
+  --changed <branch>     Only check files changed against a branch (default: main)
+  --docs                 Print rules documentation as markdown`,
     },
     zh: {
         'parens.mismatch': "括号不匹配：{0} 个 '(' vs {1} 个 ')'（{2}）",
@@ -225,6 +229,9 @@ Options:
         promise_handler: 'vlax-invoke/vlax-invoke-method 没有回调处理器——结果可能丢失',
         module_cycle: '检测到模块循环依赖——可能导致初始化问题',
         arg_count_project: "函数 '{0}' 调用时传入了 {1} 个参数，但定义为 {2} 个（跨文件）",
+        redundant_entmake: '(entmake (list (cons ...))) 应使用 quoted 关联表以提升性能',
+        missing_princ: "C: 命令 '{0}' 末尾缺少 (princ) — 可能在命令行返回 nil",
+        global_function_naming: "函数 '{0}' 缺少包名前缀 — 建议使用 namespace: 前缀",
         'help.text': `@atlisp/lint - AutoLISP 静态分析工具
 
 用法: atlisp-lint [选项]
@@ -248,9 +255,10 @@ Options:
   --help                  显示此帮助信息
   --version               显示版本号
   --format-code           自动格式化代码缩进
-  --format-check          检查文件是否已格式化（未格式化则退出码为 1）
-  --diff                  仅检查自上次提交后变更的文件
-  --changed <分支>        仅检查相对于某分支有变更的文件（默认：main）`,
+  --format-check        检查文件是否已格式化（未格式化则退出码为 1）
+  --diff                仅检查自上次提交后变更的文件
+  --changed <分支>        仅检查相对于某分支有变更的文件（默认：main）
+  --docs                打印规则文档（Markdown 格式）`,
     },
 };
 let currentLocale = 'zh';

package/dist/presets.js

@@ -74,6 +74,9 @@ exports.PRESETS = {
             promise_handler: 'off',
             module_cycle: 'warn',
             arg_count_project: 'warn',
+            redundant_entmake: 'warn',
+            missing_princ: 'warn',
+            global_function_naming: 'info',
         },
     },
     strict: {
@@ -160,6 +163,9 @@ exports.PRESETS = {
             promise_handler: 'off',
             module_cycle: 'error',
             arg_count_project: 'error',
+            redundant_entmake: 'error',
+            missing_princ: 'error',
+            global_function_naming: 'error',
         },
     },
     relaxed: {

package/dist/rules.d.ts

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

package/dist/rules.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RULES = void 0;
 exports.generateRulesMarkdown = generateRulesMarkdown;
+exports.generateSchemaHint = generateSchemaHint;
 exports.RULES = [
     {
         name: 'append_single',
@@ -256,6 +257,24 @@ exports.RULES = [
         description: '检查 AutoLISP 内置函数调用参数个数是否匹配',
         category: '正确性',
     },
+    {
+        name: 'redundant_entmake',
+        defaultSeverity: 'warn',
+        description: '检测 (entmake (list (cons ...))) 应使用 quoted 关联表',
+        category: '风格',
+    },
+    {
+        name: 'missing_princ',
+        defaultSeverity: 'warn',
+        description: '检测 C: 命令定义末尾缺少 (princ)',
+        category: '最佳实践',
+    },
+    {
+        name: 'global_function_naming',
+        defaultSeverity: 'info',
+        description: '检测 defun 函数名缺少包名前缀',
+        category: '风格',
+    },
 ];
 function generateRulesMarkdown() {
     const lines = [
@@ -269,4 +288,10 @@ function generateRulesMarkdown() {
     }
     return lines.join('\n');
 }
+function generateSchemaHint() {
+    return `You can use the JSON Schema for editor autocompletion by adding to your atlisp-lint.json:
+  "$schema": "node_modules/@atlisp/lint/atlisp-lint.schema.json"
+
+Total rules: ${exports.RULES.length}`;
+}
 //# sourceMappingURL=rules.js.map

package/dist/runner.js

@@ -86,6 +86,9 @@ const empty_comments_1 = require("./checks/empty-comments");
 const commented_code_1 = require("./checks/commented-code");
 const unused_catch_result_1 = require("./checks/unused-catch-result");
 const string_concat_loop_1 = require("./checks/string-concat-loop");
+const redundant_entmake_1 = require("./checks/redundant-entmake");
+const missing_princ_1 = require("./checks/missing-princ");
+const global_function_naming_1 = require("./checks/global-function-naming");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
@@ -162,6 +165,9 @@ function runChecks(content, file, config) {
     // New checks
     addIfEnabled('unused_catch_result', () => (0, unused_catch_result_1.checkUnusedCatchResult)(content, file));
     addIfEnabled('string_concat_loop', () => (0, string_concat_loop_1.checkStringConcatInLoop)(content, file));
+    addIfEnabled('redundant_entmake', () => (0, redundant_entmake_1.checkRedundantEntmake)(content, file));
+    addIfEnabled('missing_princ', () => (0, missing_princ_1.checkMissingPrinc)(content, file));
+    addIfEnabled('global_function_naming', () => (0, global_function_naming_1.checkGlobalFunctionNaming)(content, file));
     // AST-based checks via single-pass visitor
     const astRules = new Set([
         'quit_exit',

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

@@ -85,6 +85,9 @@ const VALID_RULES = [
     'module_cycle',
     'arg_count_project',
     'builtin_arg_count',
+    'redundant_entmake',
+    'missing_princ',
+    'global_function_naming',
 ];
 const VALID_SEVERITIES = ['off', 'info', 'warn', 'error'];
 function validateConfig(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",
@@ -21,6 +21,7 @@
     "lib/",
     "bin/",
     "atlisp-lint.default.json",
+    "atlisp-lint.schema.json",
     "stub-packages.json"
   ],
   "scripts": {
@@ -36,9 +37,6 @@
     "prepublishOnly": "npm run build",
     "prepack": "npm run build"
   },
-  "dependencies": {
-    "@atlisp/parser": "^0.1.5"
-  },
   "devDependencies": {
     "@types/jest": "^30",
     "@types/node": "^26.1.0",
@@ -54,5 +52,8 @@
   "engines": {
     "node": ">=18"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "@atlisp/parser": "^0.1.7"
+  }
 }