@atlisp/lint 0.1.3 → 0.1.4

package/dist/runner.js

@@ -33,62 +33,218 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIgnoreFile = parseIgnoreFile;
+exports.runChecks = runChecks;
+exports.runChecksWithVisitor = runChecksWithVisitor;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
 exports.fixFile = fixFile;
-exports.clearCache = clearCache;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const worker_threads_1 = require("worker_threads");
 const os = __importStar(require("os"));
-const index_1 = require("./checks/index");
+const encoding_1 = require("./checks/encoding");
+const parens_1 = require("./checks/parens");
+const cl_syntax_1 = require("./checks/cl-syntax");
+const dangerous_calls_1 = require("./checks/dangerous-calls");
+const vlax_1 = require("./checks/vlax");
+const token_in_url_1 = require("./checks/token-in-url");
+const open_close_1 = require("./checks/open-close");
+const bare_names_1 = require("./checks/bare-names");
+const module_reg_1 = require("./checks/module-reg");
+const namespace_header_1 = require("./checks/namespace-header");
+const trailing_ws_1 = require("./checks/trailing-ws");
+const line_length_1 = require("./checks/line-length");
+const function_complexity_1 = require("./checks/function-complexity");
+const parameter_naming_1 = require("./checks/parameter-naming");
+const unused_variable_1 = require("./checks/unused-variable");
+const missing_doc_1 = require("./checks/missing-doc");
+const unused_param_1 = require("./checks/unused-param");
+const constant_condition_1 = require("./checks/constant-condition");
+const redundant_progn_1 = require("./checks/redundant-progn");
+const empty_branch_1 = require("./checks/empty-branch");
+const unused_let_1 = require("./checks/unused-let");
+const recursive_call_1 = require("./checks/recursive-call");
+const variable_shadow_1 = require("./checks/variable-shadow");
+const redundant_cond_1 = require("./checks/redundant-cond");
+const unused_local_fun_1 = require("./checks/unused-local-fun");
+const multiple_setq_1 = require("./checks/multiple-setq");
+const redundant_quotes_1 = require("./checks/redundant-quotes");
+const trailing_paren_1 = require("./checks/trailing-paren");
+const empty_comments_1 = require("./checks/empty-comments");
+const redundant_setq_1 = require("./checks/redundant-setq");
+const redundant_nil_else_1 = require("./checks/redundant-nil-else");
+const single_arg_and_or_1 = require("./checks/single-arg-and-or");
+const redundant_let_1 = require("./checks/redundant-let");
+const self_compare_1 = require("./checks/self-compare");
+const misplaced_else_1 = require("./checks/misplaced-else");
+const quote_vs_function_1 = require("./checks/quote-vs-function");
+const commented_code_1 = require("./checks/commented-code");
+const double_not_1 = require("./checks/double-not");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
-const cache_1 = require("./cache");
-function parseIgnoreFile(rootDir) {
-    const ignorePath = path.join(rootDir, '.atlisp-lint-ignore');
-    if (!fs.existsSync(ignorePath))
-        return [];
-    const patterns = [];
-    for (const line of fs.readFileSync(ignorePath, 'utf-8').split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        try {
-            const str = trimmed
-                .replace(/\./g, '\\.')
-                .replace(/\*\*/g, '.*')
-                .replace(/\*/g, '[^/]*');
-            patterns.push(new RegExp(`^${str}$`));
+const disable_1 = require("./disable");
+const parser_1 = require("@atlisp/parser");
+function runChecks(content, file, config) {
+    const issues = [];
+    const disableMap = (0, disable_1.parseDisableComments)(content);
+    // Parse AST once for all checks that need it
+    const ast = (0, parser_1.parseAst)(content);
+    function addIfEnabled(rule, fn) {
+        const severity = config.checks[rule];
+        if (severity === 'off')
+            return;
+        const results = fn();
+        for (const r of results) {
+            if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
+                issues.push(r);
+            }
         }
-        catch { /* skip invalid patterns */ }
     }
-    return patterns;
+    addIfEnabled('encoding', () => (0, encoding_1.checkEncoding)(content, file));
+    addIfEnabled('parens', () => (0, parens_1.checkParens)(content, file));
+    addIfEnabled('cl_syntax', () => (0, cl_syntax_1.checkClSyntax)(content, file, config.cl_syntax.keywords));
+    addIfEnabled('quit_exit', () => (0, dangerous_calls_1.checkDangerousCallsAst)(ast, file, config.dangerous_calls));
+    addIfEnabled('vlax_without_loading', () => (0, vlax_1.checkVlaxWithoutLoading)(content, file));
+    addIfEnabled('token_in_url', () => (0, token_in_url_1.checkTokenInUrl)(content, file));
+    addIfEnabled('open_without_close', () => (0, open_close_1.checkOpenWithoutCloseAst)(ast, file));
+    addIfEnabled('bare_function_names', () => (0, bare_names_1.checkBareFunctionNames)(content, file, config.bare_function_names.allowlist, config.bare_function_names.namespace_pattern));
+    addIfEnabled('module_registration', () => (0, module_reg_1.checkModuleRegistration)(content, file, file, config.module_registration));
+    addIfEnabled('namespace_header', () => (0, namespace_header_1.checkNamespaceHeader)(content, file, config.namespace_header));
+    addIfEnabled('line_length', () => (0, line_length_1.checkLineLength)(content, file, config.line_length.max, config.line_length.tab_width));
+    addIfEnabled('function_complexity', () => (0, function_complexity_1.checkFunctionComplexityAst)(ast, file, config.function_complexity.max_lines, config.function_complexity.max_nesting));
+    addIfEnabled('parameter_naming', () => (0, parameter_naming_1.checkParameterNamingAst)(ast, file));
+    addIfEnabled('unused_variable', () => (0, unused_variable_1.checkUnusedVariableAst)(ast, file));
+    addIfEnabled('missing_doc', () => (0, missing_doc_1.checkMissingDoc)(content, file));
+    addIfEnabled('trailing_whitespace', () => (0, trailing_ws_1.checkTrailingWhitespace)(content, file));
+    addIfEnabled('unused_parameter', () => (0, unused_param_1.checkUnusedParameterAst)(ast, file));
+    addIfEnabled('constant_condition', () => (0, constant_condition_1.checkConstantConditionAst)(ast, file));
+    addIfEnabled('redundant_progn', () => (0, redundant_progn_1.checkRedundantPrognAst)(ast, file));
+    addIfEnabled('empty_branch', () => (0, empty_branch_1.checkEmptyBranchAst)(ast, file));
+    addIfEnabled('unused_let_binding', () => (0, unused_let_1.checkUnusedLetBindingAst)(ast, file));
+    addIfEnabled('recursive_call', () => (0, recursive_call_1.checkRecursiveCallAst)(ast, file));
+    addIfEnabled('variable_shadow', () => (0, variable_shadow_1.checkVariableShadowAst)(ast, file));
+    addIfEnabled('redundant_cond', () => (0, redundant_cond_1.checkRedundantCondAst)(ast, file));
+    addIfEnabled('unused_local_fun', () => (0, unused_local_fun_1.checkUnusedLocalFunAst)(ast, file));
+    addIfEnabled('multiple_setq', () => (0, multiple_setq_1.checkMultipleSetqAst)(ast, file));
+    addIfEnabled('redundant_quotes', () => (0, redundant_quotes_1.checkRedundantQuotesAst)(ast, file));
+    addIfEnabled('trailing_paren', () => (0, trailing_paren_1.checkTrailingParen)(content, file));
+    addIfEnabled('empty_comment', () => (0, empty_comments_1.checkEmptyComments)(content, file));
+    addIfEnabled('redundant_setq', () => (0, redundant_setq_1.checkRedundantSetqAst)(ast, file));
+    addIfEnabled('redundant_nil_else', () => (0, redundant_nil_else_1.checkRedundantNilElseAst)(ast, file));
+    addIfEnabled('single_arg_and_or', () => (0, single_arg_and_or_1.checkSingleArgAndOrAst)(ast, file));
+    addIfEnabled('redundant_let', () => (0, redundant_let_1.checkRedundantLetAst)(ast, file));
+    addIfEnabled('self_compare', () => (0, self_compare_1.checkSelfCompareAst)(ast, file));
+    addIfEnabled('misplaced_else', () => (0, misplaced_else_1.checkMisplacedElseAst)(ast, file));
+    addIfEnabled('quote_vs_function', () => (0, quote_vs_function_1.checkQuoteVsFunctionAst)(ast, file));
+    addIfEnabled('commented_code', () => (0, commented_code_1.checkCommentedCode)(content, file));
+    addIfEnabled('double_not', () => (0, double_not_1.checkDoubleNotAst)(ast, file));
+    return issues;
 }
-function lintFiles(files, config, rootDir, options) {
+/** Single-pass visitor-based runChecks using AstVisitor */
+function runChecksWithVisitor(content, file, config) {
+    const issues = [];
+    const disableMap = (0, disable_1.parseDisableComments)(content);
+    const ast = (0, parser_1.parseAst)(content);
+    const visitor = new parser_1.AstVisitor();
+    const checks = config.checks;
+    function addIssue(rule, line, severity, message) {
+        if (severity === 'off')
+            return;
+        if (!(0, disable_1.isDisabled)(rule, line, disableMap)) {
+            issues.push({ file, line, severity: severity, rule, message });
+        }
+    }
+    // Register all AST-based checks as visitor handlers
+    if (checks['redundant_quotes'] !== 'off') {
+        visitor.on('quote', (node) => {
+            if (node.children &&
+                node.children.length >= 2 &&
+                node.children[1].type === 'list' &&
+                node.children[1].children &&
+                node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' &&
+                node.children[1].children[0].name === 'quote') {
+                addIssue('redundant_quotes', node.pos.line, checks['redundant_quotes'], (0, locale_1.t)('redundant_quotes'));
+            }
+        });
+    }
+    if (checks['double_not'] !== 'off') {
+        visitor.on('not', (node) => {
+            if (node.children &&
+                node.children.length >= 2 &&
+                node.children[1].type === 'list' &&
+                node.children[1].children &&
+                node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' &&
+                node.children[1].children[0].name === 'not') {
+                addIssue('double_not', node.pos.line, checks['double_not'], (0, locale_1.t)('double_not'));
+            }
+        });
+    }
+    if (checks['misplaced_else'] !== 'off') {
+        visitor.on('if', (node) => {
+            if (node.children && node.children.length === 4) {
+                const cond = node.children[1];
+                if (cond.type === 'list' &&
+                    cond.children &&
+                    cond.children.length >= 2 &&
+                    cond.children[0].type === 'symbol' &&
+                    cond.children[0].name === 'not') {
+                    const innerName = cond.children[1].name || '';
+                    addIssue('misplaced_else', node.pos.line, checks['misplaced_else'], (0, locale_1.t)('misplaced_else', innerName));
+                }
+            }
+        });
+    }
+    if (checks['quote_vs_function'] !== 'off') {
+        const higherOrder = new Set([
+            'mapcar',
+            'apply',
+            'lambda',
+            'vl-sort',
+            'vl-sort-i',
+            'vl-remove-if',
+            'vl-remove-if-not',
+            'vl-member-if',
+            'vl-some',
+            'vl-every',
+        ]);
+        visitor.on('quote', (node) => {
+            if (node.children &&
+                node.children.length >= 2 &&
+                node.children[1].type === 'list' &&
+                node.children[1].children &&
+                node.children[1].children.length > 0 &&
+                node.children[1].children[0].type === 'symbol' &&
+                node.children[1].children[0].name === 'lambda') {
+                const parent = node.parent;
+                if (parent && parent.children && parent.children.length > 0) {
+                    const pName = (parent.children[0].type === 'symbol' && parent.children[0].name) || '';
+                    if (higherOrder.has(pName)) {
+                        addIssue('quote_vs_function', node.pos.line, checks['quote_vs_function'], (0, locale_1.t)('quote_vs_function', pName));
+                    }
+                }
+            }
+        });
+    }
+    visitor.run(ast);
+    return issues;
+}
+function lintFiles(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
     const allIssues = [];
-    const ignorePatterns = options?.ignorePatterns || [];
-    const useCache = options?.useCache ?? false;
-    for (let idx = 0; idx < files.length; idx++) {
-        const filepath = files[idx];
+    for (const filepath of files) {
         const relPath = path.relative(rootDir, filepath);
-        // Check ignore patterns
-        const relForward = relPath.replace(/\\/g, '/');
-        if (ignorePatterns.some(re => re.test(relForward)))
-            continue;
-        // Check cache
-        if (useCache && (0, cache_1.isCached)(filepath, rootDir))
-            continue;
-        options?.onProgress?.(idx + 1, files.length);
         let content;
         try {
             content = fs.readFileSync(filepath, 'utf-8');
         }
         catch {
             allIssues.push({
-                file: relPath, line: 1, severity: 'error', rule: 'read',
+                file: relPath,
+                line: 1,
+                severity: 'error',
+                rule: 'read',
                 message: (0, locale_1.t)('runner.read_error'),
             });
             continue;
@@ -96,61 +252,63 @@ function lintFiles(files, config, rootDir, options) {
         // Per-directory config override
         const override = (0, config_1.findOverrides)(filepath);
         const effectiveConfig = override ? (0, config_1.mergeOverrides)(config, override) : config;
-        const fileIssues = (0, index_1.runChecks)(content, relPath, effectiveConfig);
-        // Mark as cached if no issues found
-        if (useCache && fileIssues.length === 0) {
-            (0, cache_1.markCached)(filepath, rootDir);
-        }
-        allIssues.push(...fileIssues);
+        allIssues.push(...runChecks(content, relPath, effectiveConfig));
     }
     return allIssues;
 }
-function lintFilesParallel(files, config, rootDir, options) {
+function lintFilesParallel(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
-    const ignorePatterns = options?.ignorePatterns || [];
     return new Promise((resolve) => {
         const allIssues = [];
         let completed = 0;
         const maxWorkers = Math.min(os.cpus().length, files.length);
         let nextIndex = 0;
         function startWorker() {
-            if (nextIndex >= files.length) {
-                if (completed >= files.length)
-                    resolve(allIssues);
+            if (nextIndex >= files.length)
                 return;
-            }
             const idx = nextIndex++;
             const filepath = files[idx];
             const relPath = path.relative(rootDir, filepath);
-            // Check ignore patterns
-            const relForward = relPath.replace(/\\/g, '/');
-            if (ignorePatterns.some(re => re.test(relForward))) {
-                completed++;
-                startWorker();
-                if (completed >= files.length)
-                    resolve(allIssues);
-                return;
-            }
             const worker = new worker_threads_1.Worker(path.join(__dirname, 'worker.js'), {
                 workerData: { filepath, relPath, config },
-                eval: false,
             });
             worker.on('message', (msg) => {
                 allIssues.push(...msg.issues);
                 completed++;
-                options?.onProgress?.(completed, files.length);
                 worker.terminate();
                 startWorker();
                 if (completed >= files.length)
                     resolve(allIssues);
             });
-            worker.on('error', () => {
+            worker.on('error', (err) => {
+                allIssues.push({
+                    file: relPath,
+                    line: 1,
+                    severity: 'error',
+                    rule: 'worker',
+                    message: err.message,
+                });
                 completed++;
                 worker.terminate();
                 startWorker();
                 if (completed >= files.length)
                     resolve(allIssues);
             });
+            worker.on('exit', (code) => {
+                if (code !== 0) {
+                    allIssues.push({
+                        file: relPath,
+                        line: 1,
+                        severity: 'error',
+                        rule: 'worker',
+                        message: `Worker exited with code ${code}`,
+                    });
+                    completed++;
+                    startWorker();
+                    if (completed >= files.length)
+                        resolve(allIssues);
+                }
+            });
         }
         for (let i = 0; i < maxWorkers; i++) {
             startWorker();
@@ -159,34 +317,65 @@ function lintFilesParallel(files, config, rootDir, options) {
             resolve([]);
     });
 }
+const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
     let content = fs.readFileSync(filepath, 'utf-8');
     // Fix trailing whitespace
-    const wsFixed = content.split('\n').map(l => l.replace(/[ \t]+$/, '')).join('\n');
+    const wsFixed = content
+        .split('\n')
+        .map((l) => l.replace(/[ \t]+$/, ''))
+        .join('\n');
     if (wsFixed !== content) {
         content = wsFixed;
         fixes.push('trailing_whitespace');
     }
     // Fix UTF-8 BOM
-    if (content.charCodeAt(0) === 0xFEFF) {
+    if (content.charCodeAt(0) === UTF8_BOM) {
         content = content.slice(1);
         fixes.push('encoding (BOM)');
     }
-    // Fix comment style: ;text -> ; text
-    const commentFixed = content.split('\n').map(l => {
-        return l.replace(/^(\s*);([^ ;|])/gm, '$1; $2');
-    }).join('\n');
-    if (commentFixed !== content) {
-        content = commentFixed;
-        fixes.push('comment_style');
+    // Fix trailing parens: remove excess ')' from end of content
+    let openCount = 0;
+    let closeCount = 0;
+    let fixContent = content;
+    for (let i = 0; i < fixContent.length; i++) {
+        const ch = fixContent[i];
+        if (ch === '(')
+            openCount++;
+        else if (ch === ')')
+            closeCount++;
+    }
+    if (closeCount > openCount) {
+        let excess = closeCount - openCount;
+        while (excess > 0 && fixContent.endsWith(')')) {
+            fixContent = fixContent.slice(0, -1);
+            excess--;
+        }
+        // Also trim trailing whitespace after removing parens
+        fixContent = fixContent.replace(/\n[ \t]*$/, '');
+        if (fixContent !== content) {
+            content = fixContent;
+            fixes.push('trailing_paren');
+        }
+    }
+    // Fix empty comments: remove lines that are only ';' with optional whitespace
+    const lines = content.split('\n');
+    let changed = false;
+    const fixedLines = lines.map((l) => {
+        if (/^\s*;\s*$/.test(l)) {
+            changed = true;
+            return '';
+        }
+        return l;
+    });
+    if (changed) {
+        content = fixedLines.join('\n');
+        fixes.push('empty_comment');
     }
     if (fixes.length > 0) {
         fs.writeFileSync(filepath, content, 'utf-8');
     }
     return fixes;
 }
-function clearCache(rootDir) {
-    (0, cache_1.clearCache)(rootDir);
-}
 //# sourceMappingURL=runner.js.map

package/dist/sbcl.js

@@ -60,22 +60,26 @@ function runSbclLint(srcDir, sbclConfig, stubPackagesPath) {
     // Locate lint-sbcl.lisp bundled with the package
     const scriptPath = path.join(__dirname, '..', 'lib', 'lint-sbcl.lisp');
     if (!fs.existsSync(scriptPath)) {
-        return [{
-                file: 'internal', line: 1, severity: 'error', rule: 'sbcl',
+        return [
+            {
+                file: 'internal',
+                line: 1,
+                severity: 'error',
+                rule: 'sbcl',
                 message: (0, locale_1.t)('sbcl.script_not_found', scriptPath),
-            }];
+            },
+        ];
     }
     try {
         // Convert arrays to Lisp-readable format: ("a" "b")
-        const toLispList = (arr) => '(' + arr.map(s => `"${s}"`).join(' ') + ')';
-        const locale = (0, locale_1.getLocale)();
+        const toLispList = (arr) => '(' + arr.map((s) => `"${s}"`).join(' ') + ')';
         const result = (0, child_process_1.execFileSync)(sbcl, [
-            '--script', scriptPath,
+            '--script',
+            scriptPath,
             srcDir,
             stubPackagesPath,
             toLispList(sbclConfig.walk_exclude),
             toLispList(sbclConfig.defmacro_allow_files),
-            locale,
         ], {
             encoding: 'utf-8',
             maxBuffer: 50 * 1024 * 1024,
@@ -111,9 +115,7 @@ function parseSbclOutput(output, srcDir) {
             const severity = sev === 'ERROR' ? 'error' : 'warn';
             const lineno = lineStr ? parseInt(lineStr, 10) : 1;
             // Resolve relative path against srcDir
-            const resolved = filePath.includes(':')
-                ? filePath
-                : filePath.replace(/\\/g, '/');
+            const resolved = filePath.includes(':') ? filePath : filePath.replace(/\\/g, '/');
             issues.push({
                 file: resolved,
                 line: lineno,
@@ -128,7 +130,10 @@ function parseSbclOutput(output, srcDir) {
             if (sev) {
                 const msg = trimmed.replace(/^\[(ERROR|WARN|NOTE)\]\s*/, '');
                 issues.push({
-                    file: srcDir, line: 1, severity: sev, rule: 'sbcl',
+                    file: srcDir,
+                    line: 1,
+                    severity: sev,
+                    rule: 'sbcl',
                     message: msg,
                 });
             }

package/dist/worker.js

@@ -3,23 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const worker_threads_1 = require("worker_threads");
 const fs_1 = require("fs");
 const locale_1 = require("./locale");
-const index_1 = require("./checks/index");
+const runner_1 = require("./runner");
 if (worker_threads_1.parentPort && worker_threads_1.workerData) {
     const input = worker_threads_1.workerData;
     (0, locale_1.setLocale)(input.config.locale || 'zh');
     try {
         const content = (0, fs_1.readFileSync)(input.filepath, 'utf-8');
-        const issues = (0, index_1.runChecks)(content, input.relPath, input.config);
+        const issues = (0, runner_1.runChecks)(content, input.relPath, input.config);
         const output = { filepath: input.filepath, issues };
         worker_threads_1.parentPort.postMessage(output);
     }
     catch {
         const output = {
             filepath: input.filepath,
-            issues: [{
-                    file: input.relPath, line: 1, severity: 'error', rule: 'read',
+            issues: [
+                {
+                    file: input.relPath,
+                    line: 1,
+                    severity: 'error',
+                    rule: 'read',
                     message: 'Cannot read file',
-                }],
+                },
+            ],
         };
         worker_threads_1.parentPort.postMessage(output);
     }

package/lib/lint-sbcl.lisp

@@ -1,49 +1,14 @@
 ;; @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>
+;; Usage: sbcl --script lint-sbcl.lisp <src-dir> <stub-packages.json> <walk-exclude-json> <defmacro-allow-files-json>
 
 (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 ──────────────────────────────────
+;; File format: alist ((name use*) ...) — valid Lisp data
 (defun load-stub-packages (file-path)
   (flet ((ensure-pkg (name &optional use-list)
            (unless (find-package name)
@@ -87,10 +52,11 @@
         (let ((msg (princ-to-string e)))
           (cond
             ((search "not found" msg)
-             (format t "~%  [NOTE] ~a: ~a~%" rel (i18n :not-found))
+             (format t "~%  [NOTE] ~a: ~a~%" rel
+                     (subseq msg 0 (min 80 (length msg))))
              (incf *warnings*))
             (t
-             (format t "~a~%  [ERROR] ~a: ~a~%" (i18n :fail) rel (i18n :syntax-error))
+             (format t "FAIL~%  [ERROR] ~a: ~a~%" rel e)
              (incf *errors*)
              (return-from check-file))))))
     ;; Trailing whitespace
@@ -101,7 +67,7 @@
             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))
+                   (format t "~%  [WARN] ~a line ~d: trailing whitespace~%" rel lineno)
                    (incf *warnings*))))
     ;; CL-ism checks: raw content scan
     (with-open-file (s path :direction :input)
@@ -109,19 +75,19 @@
         (file-position s 0)
         (read-sequence content s)
         (when (search "#(" content)
-          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :vec-syntax))
+          (format t "~%  [WARN] ~a: #( vector syntax (not valid in AutoLISP)~%" rel)
           (incf *warnings*))
         (when (search "#\\" content)
-          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :char-syntax))
+          (format t "~%  [WARN] ~a: #\\ character literal syntax (not valid in AutoLISP)~%" rel)
           (incf *warnings*))
         (when (search "#." content)
-          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :eval-syntax))
+          (format t "~%  [WARN] ~a: #. read-time eval syntax (not valid in AutoLISP)~%" rel)
           (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))
+          (format t "~%  [WARN] ~a: defmacro (not valid in AutoLISP)~%" rel)
           (incf *warnings*))))
-    (format t "~a~%" (i18n :ok))))
+    (format t "OK~%")))
 
 ;; ── Main ──────────────────────────────────────────────────────────────
 (defun main ()
@@ -133,26 +99,25 @@
                           '(".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))
+                            '("compat-cl"))))
+    ;; Load stub packages for CAD runtime symbols
     (load-stub-packages stub-file)
 
     (format t "~%==================================================~%")
-    (format t "~a~%" (i18n :header))
-    (format t "~a: ~a~%" (i18n :source) (namestring (pathname src-dir)))
+    (format t "  @lisp SBCL Lint~%")
+    (format t "  Source: ~a~%" (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)))
+      (format t "  Found ~d .lsp files~%~%" (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 "  Scanned: ~d files~%" *checked*)
+    (format t "  Errors: ~d~%" *errors*)
+    (format t "  Warnings: ~d~%" *warnings*)
     (format t "==================================================~%~%")
     (if (> *errors* 0)
         (uiop:quit 1)