@atlisp/lint 0.1.3 → 0.1.4

package/dist/locale.js

@@ -9,54 +9,55 @@ const messages = {
         'encoding.bom': 'UTF-8 BOM detected',
         'encoding.non_utf8_cad': 'Non-UTF-8 encoding (may cause CAD bracket matching errors)',
         'encoding.non_utf8': 'Non-UTF-8 encoding detected',
-        'cl_syntax': "Common Lisp syntax '{0}' (not valid in AutoLISP)",
+        cl_syntax: "Common Lisp syntax '{0}' (not valid in AutoLISP)",
         'dangerous.quit': 'quit call (terminates CAD process)',
         'dangerous.exit': 'exit call (terminates CAD process)',
         'dangerous.command_shell': 'command shell call (shell injection risk)',
         'dangerous.startapp': 'startapp call (launches external process)',
         'dangerous.vl_registry_write': 'vl-registry-write call (modifies Windows registry)',
-        'vlax_without_loading': 'vlax-* call without vl-load-com in file',
-        'token_in_url': 'Possible token exposure in string: token= in URL',
-        'open_without_close': 'File has {0} open() calls but {1} close() calls (possible resource leak)',
-        'bare_function_names': "Unnamespaced function '{0}' (missing @:: or C: prefix)",
-        'module_registration': 'Module file missing @::*modules* registration (expected in last lines)',
+        vlax_without_loading: 'vlax-* call without vl-load-com in file',
+        token_in_url: 'Possible token exposure in string: token= in URL',
+        open_without_close: 'File has {0} open() calls but {1} close() calls (possible resource leak)',
+        bare_function_names: "Unnamespaced function '{0}' (missing @:: or C: prefix)",
+        module_registration: 'Module file missing @::*modules* registration (expected in last lines)',
         'namespace_header.missing': 'Missing (in-package {0}) header',
         'namespace_header.wrong': 'in-package target is not {0}',
-        'trailing_whitespace': 'Trailing whitespace',
-        'line_length': 'Line length {0} exceeds {1} characters',
+        trailing_whitespace: 'Trailing whitespace',
+        line_length: 'Line length {0} exceeds {1} characters',
         'function_complexity.lines': "Function '{0}' has {1} lines (max {2})",
         'function_complexity.nesting': "Function '{0}' nesting depth {1} exceeds {2}",
-        'parameter_naming': "Parameter '{0}' in '{1}' starts with uppercase (AutoLISP convention: lowercase)",
-        'unused_variable': "Variable '{0}' is set but never used",
-        'missing_doc': "Function '{0}' is missing a documentation comment",
-        'error_handling': "Function '{0}' uses command but has no *error* handler",
-        'global_naming': "Global variable '{0}' should be wrapped in *...*",
-        'extra_parens': "Suspicious closing parens: {0} ')' on a single line",
-        'arg_count': "Call to '{0}' has {1} argument(s) but definition expects {2}",
-        'strcat_usage': "Use strcat instead of + for string concatenation",
-        'cond_simplify': "Single-branch cond can be simplified to if",
-        'redundant_progn': "Redundant progn in branch (if/when/cond already has implicit progn)",
-        'quote_style': "Use ' instead of (quote ...)",
-        'eq_usage': "Use = for numeric comparison instead of eq",
-        'lambda_syntax': "Use #' instead of (function (lambda ...))",
-        'comment_style': "Comment should start with ; followed by a space",
-        'empty_catch': "vl-catch-all-apply result not checked with vl-catch-all-error-p",
-        'nth_usage': 'Use car instead of (nth 0 ...)',
-        'append_single': 'Use cons instead of (append (list ...))',
-        'setq_multiple': 'Combine multiple setq into one (setq a 1 b 2)',
-        'function_order': "Function '{0}' defined after its first use",
-        'magic_number': 'Magic number {0} should be a named constant',
-        'mixed_indent': 'Mixed tabs and spaces in indentation',
-        'long_function_call': 'Function call has {0} arguments, consider splitting across lines',
-        'no_return': "Function '{0}' has no return value",
-        'shadow_builtin': "Function '{0}' shadows a built-in AutoLISP function",
-        'dynamic_doc': "Command '{0}' may be missing trailing (princ) for clean exit",
-        'loop_optimization': 'Consider using foreach with a lambda instead of while/assoc loop',
-        'type_check': "Variable '{0}' from getvar should be type-checked before use",
-        'redundant_if': "Redundant progn in if/when/unless branch",
+        parameter_naming: "Parameter '{0}' in '{1}' starts with uppercase (AutoLISP convention: lowercase)",
+        unused_variable: "Variable '{0}' is set but never used",
+        missing_doc: "Function '{0}' is missing a documentation comment",
+        unused_parameter: "Parameter '{0}' in '{1}' is never used",
+        constant_condition: "Constant condition '{0}' in {1} — possibly leftover debug code",
+        redundant_progn: 'Redundant progn in {0}: only one form inside',
+        empty_branch: "Empty branch in '{0}' — no body forms",
+        unused_let_binding: "Let binding '{0}' is never used",
+        recursive_call: "Function '{0}' calls itself — possible infinite recursion",
+        variable_shadow: "Variable '{0}' is set with setq inside a let that binds the same name",
+        'redundant_cond.single': 'Single-clause {0} — simplify to (if ...)',
+        'redundant_cond.t_last': '{0} with T as last clause condition — use (if ...) else branch instead',
+        unused_local_fun: "Local function/variable '{0}' is defined in defun with / but never used",
+        multiple_setq: 'Consecutive (setq ...) forms — consider merging into a single (setq ...)',
+        redundant_quotes: "Redundant double quote — ''x can be simplified to 'x",
+        trailing_paren: "Excess closing parenthesis: {0} extra ')' found",
+        empty_comment: 'Empty comment line — contains only a semicolon with no text',
+        redundant_setq: "Redundant setq: variable '{0}' is set to itself",
+        redundant_nil_else: 'Redundant nil else branch — (if cond x nil) can be (if cond x)',
+        single_arg_and_or: 'Single-argument {0} — simplifies to just the argument',
+        redundant_let: 'let with no bindings — use (progn ...) instead',
+        self_compare: 'Self-comparison {0} is always T or always nil',
+        misplaced_else: '(if (not {0}) ...) — swap branches for better readability: (if {0} ... ... reversed)',
+        quote_vs_function: 'Quoted lambda passed to {0} — use (function (lambda ...)) instead for compiled code',
+        commented_code: 'Commented-out code detected — remove or uncomment if needed',
+        double_not: 'Double (not (not ...)) — simplifies to single not',
+        dangling_defun: "Function '{0}' is defined but never called",
+        missing_export: "Function '{0}' is not registered in @::*modules*",
+        unused_package_dep: "Imported package '{0}' is never referenced",
         'runner.read_error': 'Cannot read file',
         'sbcl.script_not_found': 'lint-sbcl.lisp not found at {0}',
-        'sbcl.not_found': "SBCL (Steel Bank Common Lisp) is required but not found.\nInstall it from: https://www.sbcl.org/platform-table.html\nOr on Windows via: winget install sbcl\nOr on macOS via: brew install sbcl\nOr on Linux via: apt install sbcl",
+        'sbcl.not_found': 'SBCL (Steel Bank Common Lisp) is required but not found.\nInstall it from: https://www.sbcl.org/platform-table.html\nOr on Windows via: winget install sbcl\nOr on macOS via: brew install sbcl\nOr on Linux via: apt install sbcl',
         'summary.tag_fail': 'FAIL',
         'summary.tag_warn': 'WARN',
         'summary.line': 'Line',
@@ -65,72 +66,69 @@ const messages = {
         'summary.errors_warnings': '  {0} error(s), {1} warning(s)',
         'summary.done': '=== Done ===',
         'index.no_files': 'No .lsp files found',
-        'index.config_exists': '.atlisp-lint.json already exists',
+        'index.config_exists': 'atlisp-lint.json already exists',
         'index.config_created': 'Created {0}',
         'index.not_git': 'Not a git repository: no .git/hooks directory',
         'index.hook_installed': 'Installed pre-commit hook at {0}',
         'index.fixed': 'Auto-fixed: {0}',
-        'index.watching': 'Watching for changes',
-        'index.watch_hint': 'Press Ctrl+C to stop',
-        'index.watch_status': 'Checked {0} files, {1} errors, {2} warnings',
-        'index.config_valid': 'Configuration is valid',
+        'index.cached': 'Cached, skipping',
+        'index.all_cached': 'All files are cached, nothing to lint',
         'index.cache_cleared': 'Cache cleared',
-        'index.progress': 'Progress: {0}/{1} ({2}%)',
-        'index.max_warnings': 'Max warnings exceeded',
     },
     zh: {
         'parens.mismatch': "括号不匹配：{0} 个 '(' vs {1} 个 ')'（{2}）",
         'encoding.bom': '检测到 UTF-8 BOM',
         'encoding.non_utf8_cad': '非 UTF-8 编码（可能导致 CAD 括号匹配错误）',
         'encoding.non_utf8': '检测到非 UTF-8 编码',
-        'cl_syntax': "Common Lisp 语法 '{0}'（在 AutoLISP 中无效）",
+        cl_syntax: "Common Lisp 语法 '{0}'（在 AutoLISP 中无效）",
         'dangerous.quit': 'quit 调用（会终止 CAD 进程）',
         'dangerous.exit': 'exit 调用（会终止 CAD 进程）',
         'dangerous.command_shell': 'command shell 调用（存在命令注入风险）',
         'dangerous.startapp': 'startapp 调用（会启动外部程序）',
         'dangerous.vl_registry_write': 'vl-registry-write 调用（会修改 Windows 注册表）',
-        'vlax_without_loading': '文件中使用了 vlax-* 函数但未调用 vl-load-com',
-        'token_in_url': '字符串中可能泄露令牌：URL 中包含 token=',
-        'open_without_close': '文件中有 {0} 个 open() 调用，但只有 {1} 个 close() 调用（可能存在资源泄露）',
-        'bare_function_names': "函数 '{0}' 缺少命名空间前缀（缺少 @:: 或 C: 前缀）",
-        'module_registration': '模块文件缺少 @::*modules* 注册（应在文件末尾附近）',
+        vlax_without_loading: '文件中使用了 vlax-* 函数但未调用 vl-load-com',
+        token_in_url: '字符串中可能泄露令牌：URL 中包含 token=',
+        open_without_close: '文件中有 {0} 个 open() 调用，但只有 {1} 个 close() 调用（可能存在资源泄露）',
+        bare_function_names: "函数 '{0}' 缺少命名空间前缀（缺少 @:: 或 C: 前缀）",
+        module_registration: '模块文件缺少 @::*modules* 注册（应在文件末尾附近）',
         'namespace_header.missing': '缺少 (in-package {0}) 头',
         'namespace_header.wrong': 'in-package 目标不是 {0}',
-        'trailing_whitespace': '行尾有多余空格',
-        'line_length': '行长度 {0} 超过 {1} 个字符',
+        trailing_whitespace: '行尾有多余空格',
+        line_length: '行长度 {0} 超过 {1} 个字符',
         'function_complexity.lines': "函数 '{0}' 有 {1} 行（最大 {2} 行）",
         'function_complexity.nesting': "函数 '{0}' 嵌套深度 {1} 超过 {2}",
-        'parameter_naming': "参数 '{0}' 在 '{1}' 中首字母大写（AutoLISP 惯例：小写）",
-        'unused_variable': "变量 '{0}' 被赋值但从未使用",
-        'missing_doc': "函数 '{0}' 缺少注释说明",
-        'error_handling': "函数 '{0}' 使用了 command 但没有 *error* 错误处理",
-        'global_naming': "全局变量 '{0}' 应使用 *...* 包裹",
-        'extra_parens': "可疑的连续右括号：单行出现 {0} 个 ')'",
-        'arg_count': "调用 '{0}' 有 {1} 个参数，但定义需要 {2} 个",
-        'strcat_usage': "字符串拼接应使用 strcat 而非 +",
-        'cond_simplify': "单分支 cond 可以简化为 if",
-        'redundant_progn': "分支中存在多余的 progn（if/when/cond 已隐含 progn）",
-        'quote_style': "使用 ' 代替 (quote ...)",
-        'eq_usage': "数字比较应使用 = 而非 eq",
-        'lambda_syntax': "使用 #' 代替 (function (lambda ...))",
-        'comment_style': "注释应在 ; 后加一个空格",
-        'empty_catch': "vl-catch-all-apply 的结果未用 vl-catch-all-error-p 检查",
-        'nth_usage': "使用 car 代替 (nth 0 ...)",
-        'append_single': "使用 cons 代替 (append (list ...))",
-        'setq_multiple': "多个 setq 可以合并为一个 (setq a 1 b 2)",
-        'function_order': "函数 '{0}' 定义在使用之后",
-        'magic_number': "魔法数字 {0} 应定义为命名常量",
-        'mixed_indent': "缩进中混用了 tab 和空格",
-        'long_function_call': "函数调用有 {0} 个参数，建议换行",
-        'no_return': "函数 '{0}' 没有返回值",
-        'shadow_builtin': "函数 '{0}' 覆盖了 AutoLISP 内置函数",
-        'dynamic_doc': "命令 '{0}' 可能缺少尾部的 (princ) 以实现干净退出",
-        'loop_optimization': '建议使用 foreach + lambda 替代 while/assoc 循环',
-        'type_check': "变量 '{0}' 来自 getvar，使用前应做类型检查",
-        'redundant_if': 'if/when/unless 分支中存在冗余的 progn',
+        parameter_naming: "参数 '{0}' 在 '{1}' 中首字母大写（AutoLISP 惯例：小写）",
+        unused_variable: "变量 '{0}' 被赋值但从未使用",
+        missing_doc: "函数 '{0}' 缺少注释说明",
+        unused_parameter: "参数 '{0}' 在函数 '{1}' 中从未使用",
+        constant_condition: "常量条件 '{0}' 在 {1} 中——可能是调试残留代码",
+        redundant_progn: '冗余 progn：{0} 内只有一个表达式',
+        empty_branch: "'{0}' 的条件分支为空——没有表达式",
+        unused_let_binding: "let 绑定 '{0}' 从未被使用",
+        recursive_call: "函数 '{0}' 调用了自身——可能存在无限递归",
+        variable_shadow: "变量 '{0}' 在 let 绑定了相同名称后被 setq 赋值",
+        'redundant_cond.single': '单子句 {0} ——建议简化为 (if ...)',
+        'redundant_cond.t_last': '{0} 的最后一条子句条件为 T ——建议改用 (if ...) else 分支',
+        unused_local_fun: "局部函数/变量 '{0}' 在 defun 的 / 后定义但从未使用",
+        multiple_setq: '连续多个 (setq ...) ——建议合并为一个 (setq ...)',
+        redundant_quotes: "冗余双引号 —— ''x 可以简化为 'x",
+        trailing_paren: "多余闭合括号：发现 {0} 个额外的 ')'",
+        empty_comment: '空注释行 —— 分号后没有内容',
+        redundant_setq: "冗余 setq：变量 '{0}' 赋值为自身",
+        redundant_nil_else: '冗余 nil 分支 —— (if cond x nil) 可简化为 (if cond x)',
+        single_arg_and_or: '单参数 {0} —— 可直接简化为该参数本身',
+        redundant_let: '无绑定的 let —— 建议改用 (progn ...)',
+        self_compare: '自比较 {0} 的结果恒为 T 或恒为 nil',
+        misplaced_else: '(if (not {0}) ...) —— 建议交换分支以提高可读性: (if {0} ... ... 交换后)',
+        quote_vs_function: '在 {0} 中使用引用 lambda —— 建议改用 (function (lambda ...)) 以支持编译优化',
+        commented_code: '检测到被注释掉的代码 —— 请删除或取消注释',
+        double_not: '双重 (not (not ...)) —— 可以简化为单个 not',
+        dangling_defun: "函数 '{0}' 定义了但从未被调用",
+        missing_export: "函数 '{0}' 未注册到 @::*modules*",
+        unused_package_dep: "导入的包 '{0}' 从未被引用",
         'runner.read_error': '无法读取文件',
         'sbcl.script_not_found': '未找到 lint-sbcl.lisp：{0}',
-        'sbcl.not_found': "未找到 SBCL（Steel Bank Common Lisp）。\n请从以下地址安装：https://www.sbcl.org/platform-table.html\nWindows 下可用：winget install sbcl\nmacOS 下可用：brew install sbcl\nLinux 下可用：apt install sbcl",
+        'sbcl.not_found': '未找到 SBCL（Steel Bank Common Lisp）。\n请从以下地址安装：https://www.sbcl.org/platform-table.html\nWindows 下可用：winget install sbcl\nmacOS 下可用：brew install sbcl\nLinux 下可用：apt install sbcl',
         'summary.tag_fail': '失败',
         'summary.tag_warn': '警告',
         'summary.line': '行',
@@ -139,18 +137,14 @@ const messages = {
         'summary.errors_warnings': '  {0} 个错误，{1} 个警告',
         'summary.done': '=== 完成 ===',
         'index.no_files': '未找到 .lsp 文件',
-        'index.config_exists': '.atlisp-lint.json 已存在',
+        'index.config_exists': 'atlisp-lint.json 已存在',
         'index.config_created': '已创建 {0}',
         'index.not_git': '不是 git 仓库：没有 .git/hooks 目录',
         'index.hook_installed': '已在 {0} 安装 pre-commit hook',
         'index.fixed': '自动修复：{0}',
-        'index.watching': '正在监听文件变化',
-        'index.watch_hint': '按 Ctrl+C 停止',
-        'index.watch_status': '检查了 {0} 个文件，{1} 个错误，{2} 个警告',
-        'index.config_valid': '配置文件校验通过',
+        'index.cached': '已缓存，跳过',
+        'index.all_cached': '所有文件均已缓存，无需检查',
         'index.cache_cleared': '缓存已清除',
-        'index.progress': '进度：{0}/{1}（{2}%）',
-        'index.max_warnings': '超出最大警告数',
     },
 };
 let currentLocale = 'zh';
@@ -161,9 +155,7 @@ function getLocale() {
     return currentLocale;
 }
 function t(key, ...args) {
-    const msg = messages[currentLocale]?.[key] ||
-        messages['en']?.[key] ||
-        key;
+    const msg = messages[currentLocale]?.[key] || messages['en']?.[key] || key;
     return msg.replace(/\{(\d+)\}/g, (_, index) => String(args[Number(index)] ?? ''));
 }
 //# sourceMappingURL=locale.js.map

package/dist/project.d.ts

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

package/dist/project.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintProject = lintProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("@atlisp/parser");
+const dangling_defun_1 = require("./checks/dangling-defun");
+const missing_export_1 = require("./checks/missing-export");
+const unused_package_dep_1 = require("./checks/unused-package-dep");
+const locale_1 = require("./locale");
+function collectDefuns(file) {
+    const content = fs.readFileSync(file, 'utf-8');
+    const ast = (0, parser_1.parseAst)(content);
+    const results = [];
+    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 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            results.push({ name: node.children[1].name, line: node.pos.line });
+        }
+    }
+    return results;
+}
+function lintProject(files, config, rootDir) {
+    (0, locale_1.setLocale)(config.locale || 'zh');
+    const allIssues = [];
+    const defuns = { defuns: new Map() };
+    const fileContents = new Map();
+    for (const filepath of files) {
+        try {
+            const content = fs.readFileSync(filepath, 'utf-8');
+            fileContents.set(filepath, content);
+        }
+        catch {
+            continue;
+        }
+    }
+    for (const [filepath] of fileContents) {
+        const defunList = collectDefuns(filepath);
+        for (const d of defunList) {
+            const list = defuns.defuns.get(d.name) || [];
+            list.push({ file: filepath, line: d.line });
+            defuns.defuns.set(d.name, list);
+        }
+    }
+    for (const [filepath] of fileContents) {
+        const relPath = path.relative(rootDir, filepath);
+        const override = findProjectOverride(filepath);
+        const checks = override?.checks || config.checks;
+        if (checks['dangling_defun'] !== 'off') {
+            const danglingIssues = (0, dangling_defun_1.checkDanglingDefun)(filepath, defuns.defuns);
+            for (const iss of danglingIssues) {
+                iss.file = relPath;
+                allIssues.push(iss);
+            }
+        }
+        if (checks['missing_export'] !== 'off') {
+            const pkgDir = findPackageDir(filepath);
+            if (pkgDir) {
+                const missingIssues = (0, missing_export_1.checkMissingExport)(filepath, pkgDir, defuns.defuns);
+                for (const iss of missingIssues) {
+                    iss.file = relPath;
+                    allIssues.push(iss);
+                }
+            }
+        }
+        if (checks['unused_package_dep'] !== 'off') {
+            const depIssues = (0, unused_package_dep_1.checkUnusedPackageDep)(filepath);
+            for (const iss of depIssues) {
+                iss.file = relPath;
+                allIssues.push(iss);
+            }
+        }
+    }
+    return allIssues;
+}
+function findProjectOverride(filepath) {
+    let dir = path.dirname(filepath);
+    for (;;) {
+        const cfgPath = path.join(dir, '.atlisp-lint.json');
+        if (fs.existsSync(cfgPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(cfgPath, 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function findPackageDir(filepath) {
+    let dir = path.dirname(filepath);
+    for (;;) {
+        if (fs.existsSync(path.join(dir, 'pkg.lsp')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+//# sourceMappingURL=project.js.map

package/dist/runner.d.ts

@@ -1,14 +1,8 @@
 import { Issue, LintConfig } from './types';
-export declare function parseIgnoreFile(rootDir: string): RegExp[];
-export declare function lintFiles(files: string[], config: LintConfig, rootDir: string, options?: {
-    useCache?: boolean;
-    ignorePatterns?: RegExp[];
-    onProgress?: (done: number, total: number) => void;
-}): Issue[];
-export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string, options?: {
-    ignorePatterns?: RegExp[];
-    onProgress?: (done: number, total: number) => void;
-}): Promise<Issue[]>;
+export declare function runChecks(content: string, file: string, config: LintConfig): Issue[];
+/** Single-pass visitor-based runChecks using AstVisitor */
+export declare function runChecksWithVisitor(content: string, file: string, config: LintConfig): Issue[];
+export declare function lintFiles(files: string[], config: LintConfig, rootDir: string): Issue[];
+export declare function lintFilesParallel(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
 export declare function fixFile(filepath: string): string[];
-export declare function clearCache(rootDir: string): void;
 //# sourceMappingURL=runner.d.ts.map