@atlisp/lint 0.1.5 → 0.1.8

package/dist/runner.js

@@ -37,6 +37,8 @@ exports.runChecks = runChecks;
 exports.runChecksWithVisitor = runChecksWithVisitor;
 exports.lintFiles = lintFiles;
 exports.lintFilesParallel = lintFilesParallel;
+exports.applyFixes = applyFixes;
+exports.parseIgnoreFile = parseIgnoreFile;
 exports.fixFile = fixFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -80,6 +82,36 @@ 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 setq_single_arg_1 = require("./checks/setq-single-arg");
+const assoc_without_cdr_1 = require("./checks/assoc-without-cdr");
+const identical_branches_1 = require("./checks/identical-branches");
+const while_constant_1 = require("./checks/while-constant");
+const cond_duplicate_1 = require("./checks/cond-duplicate");
+const error_handling_1 = require("./checks/error-handling");
+const global_naming_1 = require("./checks/global-naming");
+const extra_parens_1 = require("./checks/extra-parens");
+const arg_count_1 = require("./checks/arg-count");
+const strcat_usage_1 = require("./checks/strcat-usage");
+const cond_simplify_1 = require("./checks/cond-simplify");
+const quote_style_1 = require("./checks/quote-style");
+const eq_usage_1 = require("./checks/eq-usage");
+const lambda_syntax_1 = require("./checks/lambda-syntax");
+const comment_style_1 = require("./checks/comment-style");
+const empty_catch_1 = require("./checks/empty-catch");
+const nth_usage_1 = require("./checks/nth-usage");
+const append_single_1 = require("./checks/append-single");
+const setq_multiple_1 = require("./checks/setq-multiple");
+const function_order_1 = require("./checks/function-order");
+const magic_number_1 = require("./checks/magic-number");
+const mixed_indent_1 = require("./checks/mixed-indent");
+const long_function_call_1 = require("./checks/long-function-call");
+const no_return_1 = require("./checks/no-return");
+const shadow_builtin_1 = require("./checks/shadow-builtin");
+const dynamic_doc_1 = require("./checks/dynamic-doc");
+const loop_optimization_1 = require("./checks/loop-optimization");
+const type_check_1 = require("./checks/type-check");
+const redundant_if_1 = require("./checks/redundant-if");
+const format_indent_1 = require("./checks/format-indent");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
@@ -87,11 +119,47 @@ 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);
+    // Deferred AST parsing: only parse if any AST-based checks are enabled
+    const astRules = new Set([
+        'quit_exit',
+        'open_without_close',
+        'function_complexity',
+        'parameter_naming',
+        'unused_variable',
+        'unused_parameter',
+        'constant_condition',
+        'redundant_progn',
+        'empty_branch',
+        'unused_let_binding',
+        'recursive_call',
+        'variable_shadow',
+        'redundant_cond',
+        'unused_local_fun',
+        'multiple_setq',
+        'redundant_quotes',
+        'redundant_setq',
+        'redundant_nil_else',
+        'single_arg_and_or',
+        'redundant_let',
+        'self_compare',
+        'misplaced_else',
+        'quote_vs_function',
+        'double_not',
+        'setq_single_arg',
+        'assoc_without_cdr',
+        'identical_branches',
+        'while_constant',
+        'cond_duplicate',
+    ]);
+    const checks = config.checks;
+    const needsAst = Array.from(astRules).some(r => checks[r] !== 'off');
+    let ast;
+    if (needsAst) {
+        ast = (0, parser_1.parseAst)(content);
+    }
     function addIfEnabled(rule, fn) {
         const severity = config.checks[rule];
-        if (severity === 'off')
+        if (!severity || severity === 'off')
             return;
         const results = fn();
         for (const r of results) {
@@ -138,6 +206,36 @@ function runChecks(content, file, config) {
     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));
+    addIfEnabled('setq_single_arg', () => (0, setq_single_arg_1.checkSetqSingleArgAst)(ast, file));
+    addIfEnabled('assoc_without_cdr', () => (0, assoc_without_cdr_1.checkAssocWithoutCdrAst)(ast, file));
+    addIfEnabled('identical_branches', () => (0, identical_branches_1.checkIdenticalBranchesAst)(ast, file));
+    addIfEnabled('while_constant', () => (0, while_constant_1.checkWhileConstantAst)(ast, file));
+    addIfEnabled('cond_duplicate', () => (0, cond_duplicate_1.checkCondDuplicateAst)(ast, file));
+    addIfEnabled('error_handling', () => (0, error_handling_1.checkErrorHandling)(content, file));
+    addIfEnabled('global_naming', () => (0, global_naming_1.checkGlobalNaming)(content, file));
+    addIfEnabled('extra_parens', () => (0, extra_parens_1.checkExtraParens)(content, file));
+    addIfEnabled('arg_count', () => (0, arg_count_1.checkArgCount)(content, file));
+    addIfEnabled('strcat_usage', () => (0, strcat_usage_1.checkStrcatUsage)(content, file));
+    addIfEnabled('cond_simplify', () => (0, cond_simplify_1.checkCondSimplify)(content, file));
+    addIfEnabled('quote_style', () => (0, quote_style_1.checkQuoteStyle)(content, file));
+    addIfEnabled('eq_usage', () => (0, eq_usage_1.checkEqUsage)(content, file));
+    addIfEnabled('lambda_syntax', () => (0, lambda_syntax_1.checkLambdaSyntax)(content, file));
+    addIfEnabled('comment_style', () => (0, comment_style_1.checkCommentStyle)(content, file));
+    addIfEnabled('empty_catch', () => (0, empty_catch_1.checkEmptyCatch)(content, file));
+    addIfEnabled('nth_usage', () => (0, nth_usage_1.checkNthUsage)(content, file));
+    addIfEnabled('append_single', () => (0, append_single_1.checkAppendSingle)(content, file));
+    addIfEnabled('setq_multiple', () => (0, setq_multiple_1.checkSetqMultiple)(content, file));
+    addIfEnabled('function_order', () => (0, function_order_1.checkFunctionOrder)(content, file));
+    addIfEnabled('magic_number', () => (0, magic_number_1.checkMagicNumber)(content, file));
+    addIfEnabled('mixed_indent', () => (0, mixed_indent_1.checkMixedIndent)(content, file));
+    addIfEnabled('long_function_call', () => (0, long_function_call_1.checkLongFunctionCall)(content, file, 6));
+    addIfEnabled('no_return', () => (0, no_return_1.checkNoReturn)(content, file));
+    addIfEnabled('shadow_builtin', () => (0, shadow_builtin_1.checkShadowBuiltin)(content, file));
+    addIfEnabled('dynamic_doc', () => (0, dynamic_doc_1.checkDynamicDoc)(content, file));
+    addIfEnabled('loop_optimization', () => (0, loop_optimization_1.checkLoopOptimization)(content, file));
+    addIfEnabled('type_check', () => (0, type_check_1.checkTypeCheck)(content, file));
+    addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
+    addIfEnabled('format_indent', () => (0, format_indent_1.checkFormatIndent)(content, file));
     return issues;
 }
 /** Single-pass visitor-based runChecks using AstVisitor */
@@ -156,7 +254,7 @@ function runChecksWithVisitor(content, file, config) {
     }
     // Register all AST-based checks as visitor handlers
     if (checks['redundant_quotes'] !== 'off') {
-        visitor.on('quote', (node) => {
+        visitor.on('quote', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -169,7 +267,7 @@ function runChecksWithVisitor(content, file, config) {
         });
     }
     if (checks['double_not'] !== 'off') {
-        visitor.on('not', (node) => {
+        visitor.on('not', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -182,7 +280,7 @@ function runChecksWithVisitor(content, file, config) {
         });
     }
     if (checks['misplaced_else'] !== 'off') {
-        visitor.on('if', (node) => {
+        visitor.on('if', node => {
             if (node.children && node.children.length === 4) {
                 const cond = node.children[1];
                 if (cond.type === 'list' &&
@@ -209,7 +307,7 @@ function runChecksWithVisitor(content, file, config) {
             'vl-some',
             'vl-every',
         ]);
-        visitor.on('quote', (node) => {
+        visitor.on('quote', node => {
             if (node.children &&
                 node.children.length >= 2 &&
                 node.children[1].type === 'list' &&
@@ -258,7 +356,7 @@ function lintFiles(files, config, rootDir) {
 }
 function lintFilesParallel(files, config, rootDir) {
     (0, locale_1.setLocale)(config.locale || 'zh');
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         const allIssues = [];
         let completed = 0;
         const maxWorkers = Math.min(os.cpus().length, files.length);
@@ -280,7 +378,7 @@ function lintFilesParallel(files, config, rootDir) {
                 if (completed >= files.length)
                     resolve(allIssues);
             });
-            worker.on('error', (err) => {
+            worker.on('error', err => {
                 allIssues.push({
                     file: relPath,
                     line: 1,
@@ -294,7 +392,7 @@ function lintFilesParallel(files, config, rootDir) {
                 if (completed >= files.length)
                     resolve(allIssues);
             });
-            worker.on('exit', (code) => {
+            worker.on('exit', code => {
                 if (code !== 0) {
                     allIssues.push({
                         file: relPath,
@@ -317,6 +415,225 @@ function lintFilesParallel(files, config, rootDir) {
             resolve([]);
     });
 }
+/** Find the matching close paren for the first complete form starting at `start` */
+function findMatchingParen(s, start) {
+    if (s[start] !== '(')
+        return start;
+    let depth = 0;
+    for (let i = start; i < s.length; i++) {
+        if (s[i] === '"') {
+            i++;
+            while (i < s.length && s[i] !== '"') {
+                if (s[i] === '\\')
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (s[i] === '(')
+            depth++;
+        else if (s[i] === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return s.length - 1;
+}
+/** Extract the next top-level form(s) from a string starting at `start`. Returns [form, endIdx]. */
+function extractForm(s, start) {
+    let i = start;
+    while (i < s.length && s[i] === ' ')
+        i++;
+    if (i >= s.length)
+        return ['', i];
+    if (s[i] !== '(') {
+        const m = s.slice(i).match(/^\S+/);
+        if (m)
+            return [m[0], i + m[0].length];
+        return ['', i];
+    }
+    const end = findMatchingParen(s, i);
+    return [s.slice(i, end + 1), end + 1];
+}
+function applyFixes(issues, content, filepath) {
+    const lines = content.split('\n');
+    const fixesByRule = new Map();
+    for (const iss of issues) {
+        if (iss.file !== filepath)
+            continue;
+        const set = fixesByRule.get(iss.rule) || new Set();
+        set.add(iss.line);
+        fixesByRule.set(iss.rule, set);
+    }
+    // Apply fixes from higher line numbers first to preserve offsets
+    const fixableRules = new Set([
+        'redundant_quotes',
+        'double_not',
+        'redundant_nil_else',
+        'single_arg_and_or',
+        'redundant_setq',
+        'redundant_progn',
+        'redundant_let',
+        'quote_style',
+        'redundant_if',
+        'misplaced_else',
+    ]);
+    let result = content;
+    for (const [rule, lineSet] of fixesByRule) {
+        if (!fixableRules.has(rule))
+            continue;
+        const sortedLines = Array.from(lineSet).sort((a, b) => b - a);
+        for (const line of sortedLines) {
+            const idx = line - 1;
+            if (idx < 0 || idx >= lines.length)
+                continue;
+            const lineContent = result.split('\n')[idx];
+            switch (rule) {
+                case 'redundant_quotes': {
+                    // Replace ''x with 'x on this line
+                    const fixed = lineContent.replace(/''(\S)/g, "'$1");
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'double_not': {
+                    // Replace (not (not ...)) with (not ...)
+                    const fixed = lineContent.replace(/\(not\s+\(not\s+/g, '(not ');
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'redundant_nil_else': {
+                    // Replace (if ... nil) with (if ...)
+                    const fixed = lineContent.replace(/\s+nil\s*\)$/, ')');
+                    if (fixed !== lineContent) {
+                        result = replaceLine(result, idx, fixed);
+                    }
+                    break;
+                }
+                case 'single_arg_and_or': {
+                    // Replace (and x) with x, (or x) with x
+                    const m = lineContent.match(/\((and|or)\s+([^)\s]+)\s*\)/);
+                    if (m) {
+                        result = replaceLine(result, idx, m[2]);
+                    }
+                    break;
+                }
+                case 'redundant_progn': {
+                    // (progn <single-form>) → <single-form>
+                    const proIdx = lineContent.indexOf('(progn ');
+                    if (proIdx !== -1) {
+                        const beforePro = lineContent.slice(0, proIdx);
+                        const close = findMatchingParen(lineContent, proIdx);
+                        if (close > proIdx) {
+                            const inner = lineContent.slice(proIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforePro + inner + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'redundant_let': {
+                    // (let () body...) → (progn body...)
+                    const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    break;
+                }
+                case 'quote_style': {
+                    // (quote x) → 'x
+                    const qIdx = lineContent.indexOf('(quote ');
+                    if (qIdx !== -1) {
+                        const beforeQ = lineContent.slice(0, qIdx);
+                        const close = findMatchingParen(lineContent, qIdx);
+                        if (close > qIdx) {
+                            const quoted = lineContent.slice(qIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforeQ + "'" + quoted + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'redundant_if': {
+                    // (if/when/unless (progn ...) ...) → remove inner progn
+                    const pIdx = lineContent.indexOf('(progn ');
+                    if (pIdx !== -1) {
+                        const beforeP = lineContent.slice(0, pIdx);
+                        const close = findMatchingParen(lineContent, pIdx);
+                        if (close > pIdx) {
+                            const inner = lineContent.slice(pIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforeP + inner + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'misplaced_else': {
+                    // (if (not x) then else) → (if x else then)
+                    const ifStart = lineContent.indexOf('(if (not ');
+                    if (ifStart !== -1) {
+                        const notIdx = lineContent.indexOf('(not ', ifStart);
+                        if (notIdx === -1)
+                            break;
+                        const notClose = findMatchingParen(lineContent, notIdx);
+                        if (notClose <= notIdx)
+                            break;
+                        const ifClose = findMatchingParen(lineContent, ifStart);
+                        if (ifClose <= ifStart)
+                            break;
+                        const indent = lineContent.slice(0, ifStart);
+                        const condVar = lineContent.slice(notIdx + 5, notClose);
+                        const branchContent = lineContent.slice(notClose + 1, ifClose).trim();
+                        const [thenForm, thenEnd] = extractForm(branchContent, 0);
+                        const elseForm = branchContent.slice(thenEnd).trim();
+                        if (thenForm && elseForm) {
+                            const rest = lineContent.slice(ifClose + 1);
+                            const fixed = indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'redundant_setq': {
+                    // Remove (setq x x) lines
+                    const allLines = result.split('\n');
+                    const trimmed = allLines[idx].trim();
+                    if (/^\(setq\s+(\S+)\s+\1\s*\)$/.test(trimmed)) {
+                        allLines.splice(idx, 1);
+                        result = allLines.join('\n');
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+function replaceLine(content, lineIdx, newLine) {
+    const lines = content.split('\n');
+    lines[lineIdx] = newLine;
+    return lines.join('\n');
+}
+function parseIgnoreFile(rootDir) {
+    const ignoreFile = path.join(rootDir, '.atlisp-lint-ignore');
+    if (!fs.existsSync(ignoreFile))
+        return [];
+    const content = fs.readFileSync(ignoreFile, 'utf-8');
+    return content
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.length > 0 && !l.startsWith('#'));
+}
 const UTF8_BOM = 0xfeff;
 function fixFile(filepath) {
     const fixes = [];
@@ -324,7 +641,7 @@ function fixFile(filepath) {
     // Fix trailing whitespace
     const wsFixed = content
         .split('\n')
-        .map((l) => l.replace(/[ \t]+$/, ''))
+        .map(l => l.replace(/[ \t]+$/, ''))
         .join('\n');
     if (wsFixed !== content) {
         content = wsFixed;
@@ -362,7 +679,7 @@ function fixFile(filepath) {
     // Fix empty comments: remove lines that are only ';' with optional whitespace
     const lines = content.split('\n');
     let changed = false;
-    const fixedLines = lines.map((l) => {
+    const fixedLines = lines.map(l => {
         if (/^\s*;\s*$/.test(l)) {
             changed = true;
             return '';

package/dist/sbcl.js

@@ -72,7 +72,7 @@ function runSbclLint(srcDir, sbclConfig, stubPackagesPath) {
     }
     try {
         // Convert arrays to Lisp-readable format: ("a" "b")
-        const toLispList = (arr) => '(' + arr.map((s) => `"${s}"`).join(' ') + ')';
+        const toLispList = (arr) => '(' + arr.map(s => `"${s}"`).join(' ') + ')';
         const result = (0, child_process_1.execFileSync)(sbcl, [
             '--script',
             scriptPath,

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/types.d.ts

@@ -1,10 +1,15 @@
 export type Severity = 'off' | 'warn' | 'error';
+export interface Fix {
+    range: [number, number];
+    replacement: string;
+}
 export interface Issue {
     file: string;
     line: number;
     severity: Severity;
     rule: string;
     message: string;
+    fix?: Fix;
 }
 export interface CheckConfig {
     severity: Severity;
@@ -61,6 +66,7 @@ export interface LintConfig {
     namespace_header: NamespaceHeaderConfig;
     bare_function_names: BareFunctionNamesConfig;
     sbcl: SbclConfig;
+    preset?: string;
 }
 export interface FormattedResult {
     issues: Issue[];

package/dist/validate.d.ts

@@ -0,0 +1,8 @@
+import { LintConfig } from './types';
+interface ValidationError {
+    path: string;
+    message: string;
+}
+export declare function validateConfig(config: LintConfig): ValidationError[];
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+const VALID_RULES = [
+    'append_single',
+    'arg_count',
+    'assoc_without_cdr',
+    'bare_function_names',
+    'cl_syntax',
+    'command_shell',
+    'comment_style',
+    'commented_code',
+    'cond_simplify',
+    'cond_duplicate',
+    'constant_condition',
+    'dangling_defun',
+    'double_not',
+    'duplicate_defun',
+    'dynamic_doc',
+    'empty_branch',
+    'empty_catch',
+    'empty_comment',
+    'encoding',
+    'eq_usage',
+    'error_handling',
+    'extra_parens',
+    'format_indent',
+    'function_complexity',
+    'function_order',
+    'global_naming',
+    'identical_branches',
+    'lambda_syntax',
+    'line_length',
+    'long_function_call',
+    'loop_optimization',
+    'magic_number',
+    'misplaced_else',
+    'missing_doc',
+    'missing_export',
+    'mixed_indent',
+    'module_registration',
+    'multiple_setq',
+    'namespace_header',
+    'no_return',
+    'nth_usage',
+    'open_without_close',
+    'parameter_naming',
+    'parens',
+    'quit_exit',
+    'quote_style',
+    'quote_vs_function',
+    'recursive_call',
+    'redundant_cond',
+    'redundant_if',
+    'redundant_let',
+    'redundant_nil_else',
+    'redundant_progn',
+    'redundant_quotes',
+    'redundant_setq',
+    'self_compare',
+    'setq_multiple',
+    'setq_single_arg',
+    'shadow_builtin',
+    'single_arg_and_or',
+    'startapp',
+    'strcat_usage',
+    'token_in_url',
+    'trailing_paren',
+    'trailing_whitespace',
+    'type_check',
+    'unused_let_binding',
+    'unused_local_fun',
+    'unused_package_dep',
+    'unused_parameter',
+    'unused_variable',
+    'variable_shadow',
+    'while_constant',
+    'vl_registry_write',
+    'vlax_without_loading',
+];
+const VALID_SEVERITIES = ['off', 'warn', 'error'];
+function validateConfig(config) {
+    const errors = [];
+    if (config.locale && config.locale !== 'zh' && config.locale !== 'en') {
+        errors.push({ path: 'locale', message: `Invalid locale '${config.locale}', expected 'zh' or 'en'` });
+    }
+    if (config.checks) {
+        for (const [rule, sev] of Object.entries(config.checks)) {
+            if (!VALID_RULES.includes(rule)) {
+                errors.push({ path: `checks.${rule}`, message: `Unknown rule '${rule}'` });
+            }
+            if (!VALID_SEVERITIES.includes(sev)) {
+                errors.push({
+                    path: `checks.${rule}`,
+                    message: `Invalid severity '${sev}', expected 'off', 'warn', or 'error'`,
+                });
+            }
+        }
+    }
+    if (config.source) {
+        if (!Array.isArray(config.source.globs)) {
+            errors.push({ path: 'source.globs', message: 'Must be an array of glob patterns' });
+        }
+        if (!Array.isArray(config.source.exclude)) {
+            errors.push({ path: 'source.exclude', message: 'Must be an array of glob patterns' });
+        }
+    }
+    if (config.line_length) {
+        if (typeof config.line_length.max !== 'number' || config.line_length.max < 1) {
+            errors.push({ path: 'line_length.max', message: 'Must be a positive number' });
+        }
+        if (typeof config.line_length.tab_width !== 'number' || config.line_length.tab_width < 1) {
+            errors.push({ path: 'line_length.tab_width', message: 'Must be a positive number' });
+        }
+    }
+    if (config.function_complexity) {
+        if (typeof config.function_complexity.max_lines !== 'number' || config.function_complexity.max_lines < 1) {
+            errors.push({ path: 'function_complexity.max_lines', message: 'Must be a positive number' });
+        }
+        if (typeof config.function_complexity.max_nesting !== 'number' || config.function_complexity.max_nesting < 1) {
+            errors.push({ path: 'function_complexity.max_nesting', message: 'Must be a positive number' });
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=validate.js.map

package/dist/watch.d.ts

@@ -0,0 +1,9 @@
+import { LintConfig } from './types';
+interface WatchOptions {
+    rootDir: string;
+    format: 'default' | 'json';
+    config: LintConfig;
+}
+export declare function watchFiles(files: string[], options: WatchOptions): void;
+export {};
+//# sourceMappingURL=watch.d.ts.map