@atlisp/lint 0.1.5 → 0.1.8

package/dist/checks/error-handling.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkErrorHandling = checkErrorHandling;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkErrorHandling(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    let inDefun = false;
+    let defunName = '';
+    let defunStart = 0;
+    let defunText = '';
+    let hasErrorHandler = 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;
+                defunText = '';
+                hasErrorHandler = false;
+            }
+        }
+        if (inDefun) {
+            defunText += stripped + '\n';
+            if (stripped.includes('*error*'))
+                hasErrorHandler = true;
+            // Check for depth returning to 0 (end of defun)
+            let depth = 0;
+            for (const ch of stripped) {
+                if (ch === '(')
+                    depth++;
+                else if (ch === ')')
+                    depth--;
+            }
+            if (depth === 0 && defunText.trim().length > 0 && defunName) {
+                // End of defun - check if it uses command but no *error*
+                if (/\(command\b/.test(defunText) && !hasErrorHandler && !defunName.startsWith('c:')) {
+                    issues.push({
+                        file,
+                        line: defunStart,
+                        severity: 'warn',
+                        rule: 'error_handling',
+                        message: (0, locale_1.t)('error_handling', defunName),
+                    });
+                }
+                inDefun = false;
+                defunName = '';
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=error-handling.js.map

package/dist/checks/extra-parens.d.ts

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

package/dist/checks/extra-parens.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExtraParens = checkExtraParens;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkExtraParens(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    let runningDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const closeOnly = stripped.trim();
+        // Empty line resets nothing; just continue tracking depth
+        if (!closeOnly)
+            continue;
+        // Count parens on this line
+        let lineOpen = 0, lineClose = 0;
+        for (const ch of stripped) {
+            if (ch === '(')
+                lineOpen++;
+            else if (ch === ')')
+                lineClose++;
+        }
+        // Check if this line is pure closing parens
+        if (/^\)+$/.test(closeOnly)) {
+            // Only flag if these closing parens exceed the running depth
+            // (i.e., they are unmatched / extra)
+            if (lineClose > runningDepth + lineOpen) {
+                const extra = lineClose - runningDepth - lineOpen;
+                issues.push({
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'extra_parens',
+                    message: (0, locale_1.t)('extra_parens', extra),
+                });
+            }
+        }
+        runningDepth += lineOpen - lineClose;
+        if (runningDepth < 0)
+            runningDepth = 0;
+    }
+    return issues;
+}
+//# sourceMappingURL=extra-parens.js.map

package/dist/checks/format-indent.d.ts

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

package/dist/checks/format-indent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFormatIndent = checkFormatIndent;
+const formatter_1 = require("../formatter");
+function checkFormatIndent(content, file) {
+    const formatted = (0, formatter_1.formatCode)(content);
+    if (content === formatted)
+        return [];
+    // Find first line that differs for better error location
+    const originalLines = content.split('\n');
+    const formattedLines = formatted.split('\n');
+    let firstDiffLine = 1;
+    for (let i = 0; i < Math.max(originalLines.length, formattedLines.length); i++) {
+        if (originalLines[i] !== formattedLines[i]) {
+            firstDiffLine = i + 1;
+            break;
+        }
+    }
+    return [
+        {
+            file,
+            line: firstDiffLine,
+            severity: 'warn',
+            rule: 'format_indent',
+            message: 'Code indentation does not match expected format',
+        },
+    ];
+}
+//# sourceMappingURL=format-indent.js.map

package/dist/checks/function-complexity.js

@@ -41,7 +41,7 @@ function checkFunctionComplexityAst(ast, file, maxLines, maxNesting) {
         }
     }
     // Check lambda forms: (lambda (args) body...)
-    const lambdas = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'lambda'));
+    const lambdas = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'lambda'));
     for (const lam of lambdas) {
         if (!lam.children || !lam.end)
             continue;

package/dist/checks/function-order.d.ts

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

package/dist/checks/function-order.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFunctionOrder = checkFunctionOrder;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkFunctionOrder(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    const defined = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const defunM = stripped.match(/\(defun\s+(\S+)/);
+        if (defunM) {
+            const name = defunM[1];
+            if (name.includes('/') || name.startsWith('c:'))
+                continue;
+            defined.add(name);
+            continue;
+        }
+        const callM = stripped.match(/\((\S+)\s+/);
+        if (callM) {
+            const name = callM[1];
+            if (name.startsWith('(') || name === 'defun' || name.startsWith('@') || /^[a-z]+:/.test(name))
+                continue;
+            if (!defined.has(name) && name.length > 1 && /^[a-z]/.test(name)) {
+                defined.add(name);
+                issues.push({ file, line: i + 1, severity: 'warn', rule: 'function_order', message: (0, locale_1.t)('function_order', name) });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=function-order.js.map

package/dist/checks/global-naming.d.ts

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

package/dist/checks/global-naming.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGlobalNaming = checkGlobalNaming;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkGlobalNaming(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    let depth = 0;
+    let inDefun = false;
+    let defunLocals = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        // Track depth
+        for (const ch of stripped) {
+            if (ch === '(')
+                depth++;
+            else if (ch === ')')
+                depth--;
+        }
+        // Detect defun start and extract local variables
+        if (!inDefun) {
+            const defunMatch = stripped.match(/\(defun\s+\S+\s+\(([^)]*\/\s+[^)]*)\)/);
+            if (defunMatch) {
+                inDefun = true;
+                const all = defunMatch[1];
+                const slashIdx = all.indexOf('/');
+                defunLocals = new Set(all
+                    .slice(slashIdx + 1)
+                    .split(/\s+/)
+                    .filter(Boolean));
+            }
+        }
+        if (depth <= 0) {
+            inDefun = false;
+            defunLocals = new Set();
+        }
+        // setq at depth 0 or 1 (top-level or directly inside progn) is global
+        if (depth <= 1) {
+            const m = stripped.match(/\(setq\s+(\S+)/);
+            if (m) {
+                const v = m[1];
+                if (v !== 'T' &&
+                    v !== 'nil' &&
+                    !v.startsWith('*') &&
+                    !v.endsWith('*') &&
+                    !v.includes('/') &&
+                    !defunLocals.has(v)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        severity: 'warn',
+                        rule: 'global_naming',
+                        message: (0, locale_1.t)('global_naming', v),
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=global-naming.js.map

package/dist/checks/identical-branches.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkIdenticalBranches(content: string, file: string): Issue[];
+export declare function checkIdenticalBranchesAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=identical-branches.d.ts.map

package/dist/checks/identical-branches.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIdenticalBranches = checkIdenticalBranches;
+exports.checkIdenticalBranchesAst = checkIdenticalBranchesAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function astEqual(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.type === 'symbol')
+        return a.name === b.name;
+    if (a.type === 'number')
+        return a.value === b.value;
+    if (a.type === 'string')
+        return a.value === b.value;
+    if (a.type === 'list') {
+        const aChildren = a.children || [];
+        const bChildren = b.children || [];
+        if (aChildren.length !== bChildren.length)
+            return false;
+        for (let i = 0; i < aChildren.length; i++) {
+            if (!astEqual(aChildren[i], bChildren[i]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function checkIdenticalBranches(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkIdenticalBranchesAst(ast, file);
+}
+function checkIdenticalBranchesAst(ast, file) {
+    const issues = [];
+    // Check if statements: (if cond then-branch else-branch)
+    const ifNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'if'));
+    for (const node of ifNodes) {
+        if (!node.children || node.children.length < 4)
+            continue;
+        const thenBranch = node.children[2];
+        const elseBranch = node.children[3];
+        if (astEqual(thenBranch, elseBranch)) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'identical_branches',
+                message: (0, locale_1.t)('identical_branches'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=identical-branches.js.map

package/dist/checks/index.d.ts

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

package/dist/checks/index.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecks = runChecks;
+const config_1 = require("../config");
+const disable_1 = require("../disable");
+const encoding_1 = require("./encoding");
+const parens_1 = require("./parens");
+const cl_syntax_1 = require("./cl-syntax");
+const dangerous_calls_1 = require("./dangerous-calls");
+const vlax_1 = require("./vlax");
+const token_in_url_1 = require("./token-in-url");
+const open_close_1 = require("./open-close");
+const bare_names_1 = require("./bare-names");
+const module_reg_1 = require("./module-reg");
+const namespace_header_1 = require("./namespace-header");
+const line_length_1 = require("./line-length");
+const function_complexity_1 = require("./function-complexity");
+const parameter_naming_1 = require("./parameter-naming");
+const unused_variable_1 = require("./unused-variable");
+const missing_doc_1 = require("./missing-doc");
+const error_handling_1 = require("./error-handling");
+const global_naming_1 = require("./global-naming");
+const extra_parens_1 = require("./extra-parens");
+const arg_count_1 = require("./arg-count");
+const strcat_usage_1 = require("./strcat-usage");
+const cond_simplify_1 = require("./cond-simplify");
+const redundant_progn_1 = require("./redundant-progn");
+const quote_style_1 = require("./quote-style");
+const eq_usage_1 = require("./eq-usage");
+const lambda_syntax_1 = require("./lambda-syntax");
+const comment_style_1 = require("./comment-style");
+const empty_catch_1 = require("./empty-catch");
+const nth_usage_1 = require("./nth-usage");
+const append_single_1 = require("./append-single");
+const setq_multiple_1 = require("./setq-multiple");
+const function_order_1 = require("./function-order");
+const magic_number_1 = require("./magic-number");
+const mixed_indent_1 = require("./mixed-indent");
+const long_function_call_1 = require("./long-function-call");
+const no_return_1 = require("./no-return");
+const shadow_builtin_1 = require("./shadow-builtin");
+const dynamic_doc_1 = require("./dynamic-doc");
+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");
+function runChecks(content, file, config) {
+    const issues = [];
+    const disableMap = (0, disable_1.parseDisableComments)(content);
+    function addIfEnabled(rule, fn) {
+        if ((0, config_1.getCheckSeverity)(config, rule) === 'off')
+            return;
+        const results = fn();
+        for (const r of results) {
+            if (!(0, disable_1.isDisabled)(r.rule, r.line, disableMap)) {
+                issues.push(r);
+            }
+        }
+    }
+    const checks = [
+        { rule: 'encoding', fn: () => (0, encoding_1.checkEncoding)(content, file) },
+        { rule: 'parens', fn: () => (0, parens_1.checkParens)(content, file) },
+        { rule: 'cl_syntax', fn: () => (0, cl_syntax_1.checkClSyntax)(content, file, config.cl_syntax.keywords) },
+        { rule: 'quit_exit', fn: () => (0, dangerous_calls_1.checkDangerousCalls)(content, file, config.dangerous_calls) },
+        { rule: 'vlax_without_loading', fn: () => (0, vlax_1.checkVlaxWithoutLoading)(content, file) },
+        { rule: 'token_in_url', fn: () => (0, token_in_url_1.checkTokenInUrl)(content, file) },
+        { rule: 'open_without_close', fn: () => (0, open_close_1.checkOpenWithoutClose)(content, file) },
+        {
+            rule: 'bare_function_names',
+            fn: () => (0, bare_names_1.checkBareFunctionNames)(content, file, config.bare_function_names.allowlist, config.bare_function_names.namespace_pattern),
+        },
+        { rule: 'module_registration', fn: () => (0, module_reg_1.checkModuleRegistration)(content, file, file, config.module_registration) },
+        { rule: 'namespace_header', fn: () => (0, namespace_header_1.checkNamespaceHeader)(content, file, config.namespace_header) },
+        {
+            rule: 'line_length',
+            fn: () => (0, line_length_1.checkLineLength)(content, file, config.line_length.max, config.line_length.tab_width),
+        },
+        {
+            rule: 'function_complexity',
+            fn: () => (0, function_complexity_1.checkFunctionComplexity)(content, file, config.function_complexity.max_lines, config.function_complexity.max_nesting),
+        },
+        { rule: 'parameter_naming', fn: () => (0, parameter_naming_1.checkParameterNaming)(content, file) },
+        { rule: 'unused_variable', fn: () => (0, unused_variable_1.checkUnusedVariable)(content, file) },
+        { rule: 'missing_doc', fn: () => (0, missing_doc_1.checkMissingDoc)(content, file) },
+        { rule: 'error_handling', fn: () => (0, error_handling_1.checkErrorHandling)(content, file) },
+        { rule: 'global_naming', fn: () => (0, global_naming_1.checkGlobalNaming)(content, file) },
+        { rule: 'extra_parens', fn: () => (0, extra_parens_1.checkExtraParens)(content, file) },
+        { rule: 'arg_count', fn: () => (0, arg_count_1.checkArgCount)(content, file) },
+        { rule: 'strcat_usage', fn: () => (0, strcat_usage_1.checkStrcatUsage)(content, file) },
+        { rule: 'cond_simplify', fn: () => (0, cond_simplify_1.checkCondSimplify)(content, file) },
+        { rule: 'redundant_progn', fn: () => (0, redundant_progn_1.checkRedundantProgn)(content, file) },
+        { rule: 'quote_style', fn: () => (0, quote_style_1.checkQuoteStyle)(content, file) },
+        { rule: 'eq_usage', fn: () => (0, eq_usage_1.checkEqUsage)(content, file) },
+        { rule: 'lambda_syntax', fn: () => (0, lambda_syntax_1.checkLambdaSyntax)(content, file) },
+        { rule: 'comment_style', fn: () => (0, comment_style_1.checkCommentStyle)(content, file) },
+        { rule: 'empty_catch', fn: () => (0, empty_catch_1.checkEmptyCatch)(content, file) },
+        { rule: 'nth_usage', fn: () => (0, nth_usage_1.checkNthUsage)(content, file) },
+        { rule: 'append_single', fn: () => (0, append_single_1.checkAppendSingle)(content, file) },
+        { rule: 'setq_multiple', fn: () => (0, setq_multiple_1.checkSetqMultiple)(content, file) },
+        { rule: 'function_order', fn: () => (0, function_order_1.checkFunctionOrder)(content, file) },
+        { rule: 'magic_number', fn: () => (0, magic_number_1.checkMagicNumber)(content, file) },
+        { rule: 'mixed_indent', fn: () => (0, mixed_indent_1.checkMixedIndent)(content, file) },
+        { rule: 'long_function_call', fn: () => (0, long_function_call_1.checkLongFunctionCall)(content, file, 6) },
+        { rule: 'no_return', fn: () => (0, no_return_1.checkNoReturn)(content, file) },
+        { rule: 'shadow_builtin', fn: () => (0, shadow_builtin_1.checkShadowBuiltin)(content, file) },
+        { rule: 'dynamic_doc', fn: () => (0, dynamic_doc_1.checkDynamicDoc)(content, file) },
+        { rule: 'loop_optimization', fn: () => (0, loop_optimization_1.checkLoopOptimization)(content, file) },
+        { 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) },
+    ];
+    for (const c of checks) {
+        addIfEnabled(c.rule, c.fn);
+    }
+    return issues;
+}
+//# sourceMappingURL=index.js.map

package/dist/checks/lambda-syntax.d.ts

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

package/dist/checks/lambda-syntax.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLambdaSyntax = checkLambdaSyntax;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkLambdaSyntax(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]);
+        // Detect (function (lambda ...))  →  can be #'
+        const m = stripped.match(/\(function\s+\(lambda\b/);
+        if (m) {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'lambda_syntax',
+                message: (0, locale_1.t)('lambda_syntax'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=lambda-syntax.js.map

package/dist/checks/long-function-call.d.ts

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

package/dist/checks/long-function-call.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLongFunctionCall = checkLongFunctionCall;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkLongFunctionCall(content, file, maxArgs) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const m = stripped.match(/\((\S+)\s+/);
+        if (!m)
+            continue;
+        const afterName = stripped.slice(m[0].length);
+        if (!afterName || afterName === ')')
+            continue;
+        let argCount = 0, depth = 0, inArg = false;
+        for (const ch of afterName) {
+            if (ch === '(') {
+                depth++;
+                if (!inArg)
+                    inArg = true;
+            }
+            else if (ch === ')') {
+                depth--;
+                if (depth === 0 && 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 > maxArgs && !m[1].startsWith('(') && !m[1].startsWith('"') && m[1] !== 'if') {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'long_function_call',
+                message: (0, locale_1.t)('long_function_call', argCount),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=long-function-call.js.map

package/dist/checks/loop-optimization.d.ts

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

package/dist/checks/loop-optimization.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLoopOptimization = checkLoopOptimization;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkLoopOptimization(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 (/(foreach|while)\s+\S+\s+\S+/.test(stripped) && stripped.includes('assoc')) {
+            issues.push({ file, line: i + 1, severity: 'warn', rule: 'loop_optimization', message: (0, locale_1.t)('loop_optimization') });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=loop-optimization.js.map

package/dist/checks/magic-number.d.ts

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

package/dist/checks/magic-number.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMagicNumber = checkMagicNumber;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkMagicNumber(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]);
+        const m = stripped.match(/\([a-z]+\s+.*?(\d{2,})\b/);
+        if (m) {
+            const num = m[1];
+            if (num !== '10' && num !== '20' && num !== '100' && num !== '1000') {
+                issues.push({ file, line: i + 1, severity: 'warn', rule: 'magic_number', message: (0, locale_1.t)('magic_number', num) });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=magic-number.js.map

package/dist/checks/misplaced-else.js

@@ -10,7 +10,7 @@ function checkMisplacedElse(content, file) {
 }
 function checkMisplacedElseAst(ast, file) {
     const issues = [];
-    const ifNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'if'));
+    const ifNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'if'));
     for (const node of ifNodes) {
         if (!node.children || node.children.length !== 4)
             continue;

package/dist/checks/missing-export.js

@@ -45,7 +45,7 @@ function checkMissingExport(file, pkgDir, _allDefuns) {
         return issues;
     const pkgContent = fs.readFileSync(pkgLspPath, 'utf-8');
     const pkgAst = (0, parser_1.parseAst)(pkgContent);
-    const modulesNode = (0, parser_1.astFindAll)(pkgAst, (n) => (0, parser_1.astIsList)(n, 'setq'));
+    const modulesNode = (0, parser_1.astFindAll)(pkgAst, n => (0, parser_1.astIsList)(n, 'setq'));
     const registered = new Set();
     for (const node of modulesNode) {
         if (!node.children)
@@ -69,7 +69,7 @@ function checkMissingExport(file, pkgDir, _allDefuns) {
     }
     const fileContent = fs.readFileSync(file, 'utf-8');
     const ast = (0, parser_1.parseAst)(fileContent);
-    const defunNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'defun') || (0, parser_1.astIsList)(n, 'defun-q'));
+    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 < 2)
             continue;

package/dist/checks/mixed-indent.d.ts

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

package/dist/checks/mixed-indent.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMixedIndent = checkMixedIndent;
+const locale_1 = require("../locale");
+function checkMixedIndent(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        const indent = line.substring(0, line.length - line.trimStart().length);
+        if (indent.includes('\t') && indent.includes(' ')) {
+            issues.push({ file, line: i + 1, severity: 'warn', rule: 'mixed_indent', message: (0, locale_1.t)('mixed_indent') });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=mixed-indent.js.map

package/dist/checks/module-reg.js

@@ -12,7 +12,7 @@ function checkModuleRegistration(content, file, relPath, config) {
     if (!config.dirs.includes(topDir))
         return [];
     const lines = content.split('\n');
-    const relevant = lines.filter((l) => l.trim().length > 0);
+    const relevant = lines.filter(l => l.trim().length > 0);
     const tail = relevant.slice(-20).join('\n');
     if (!tail.includes('*modules*')) {
         return [