@atlisp/lint 0.2.12 → 0.2.13

package/atlisp-lint.schema.json

@@ -51,6 +51,7 @@
         "command_shell": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
         "comment_style": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "commented_code": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "command_s": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "cond_duplicate": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "cond_simplify": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "constant_condition": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
@@ -59,9 +60,11 @@
         "duplicate_defun": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "dynamic_doc": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "empty_branch": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "empty_branch_cond": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "empty_catch": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "empty_comment": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "encoding": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "equal_nil": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "entget_in_loop": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "eq_usage": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "error_handling": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
@@ -69,9 +72,11 @@
         "format_indent": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "function_complexity": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "function_order": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
+        "function_reference": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "global_function_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "global_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "identical_branches": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "if_progn_both": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "if_without_else": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
         "lambda_syntax": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
         "line_length": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
@@ -92,11 +97,16 @@
         "open_without_close": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "parameter_naming": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "parens": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
+        "progn_in_body": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "progn_in_cond": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "promise_handler": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
         "quit_exit": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
         "quote_style": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "quote_vs_function": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "recursive_call": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "redundant_and_or": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_car_cdr": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
+        "redundant_cond": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "redundant_entmake": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "redundant_if": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "redundant_let": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
@@ -105,6 +115,7 @@
         "redundant_progn": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "redundant_quotes": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" },
         "redundant_setq": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "selection_set_leak": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "self_compare": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "setq_multiple": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "setq_single_arg": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
@@ -127,7 +138,8 @@
         "variable_shadow": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "vl_registry_write": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "vlax_without_loading": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "off" },
-        "while_constant": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" }
+        "while_constant": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "zerop_usage": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "info" }
       },
       "additionalProperties": false
     },
@@ -163,7 +175,8 @@
         "exit": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "error" },
         "command_shell": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
         "startapp": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
-        "vl_registry_write": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" }
+        "vl_registry_write": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" },
+        "eval": { "type": "string", "enum": ["off", "info", "warn", "error"], "default": "warn" }
       }
     },
     "module_registration": {
@@ -200,8 +213,18 @@
     "project_analysis": {
       "type": "object",
       "properties": {
-        "maxFiles": { "type": "integer", "minimum": 1, "default": 500, "description": "Maximum number of files for cross-file analysis. Exceeding this threshold skips project analysis." },
-        "batchSize": { "type": "integer", "minimum": 1, "default": 50, "description": "Files processed per batch (reserved for future streaming)" }
+        "maxFiles": {
+          "type": "integer",
+          "minimum": 1,
+          "default": 500,
+          "description": "Maximum number of files for cross-file analysis. Exceeding this threshold skips project analysis."
+        },
+        "batchSize": {
+          "type": "integer",
+          "minimum": 1,
+          "default": 50,
+          "description": "Files processed per batch (reserved for future streaming)"
+        }
       }
     }
   }

package/dist/cache.js

@@ -43,26 +43,36 @@ const CACHE_DIR = '.atlisp-lint-cache';
 function getCacheDir(rootDir) {
     return path.join(rootDir, CACHE_DIR);
 }
-function fileHash(content) {
-    return crypto.createHash('md5').update(content).digest('hex');
+function contentKey(content) {
+    return 'hash-' + crypto.createHash('md5').update(content).digest('hex');
+}
+function statKey(filepath) {
+    try {
+        const stat = fs.statSync(filepath);
+        return `mtime-${stat.mtimeMs}-${stat.size}`;
+    }
+    catch {
+        return null;
+    }
 }
 function isCached(filepath, rootDir, content) {
     const cacheDir = getCacheDir(rootDir);
     if (!fs.existsSync(cacheDir))
         return false;
-    const src = content !== undefined ? content : fs.readFileSync(filepath, 'utf-8');
-    const hash = fileHash(src);
-    const cacheFile = path.join(cacheDir, hash);
-    return fs.existsSync(cacheFile);
+    const key = content !== undefined ? contentKey(content) : statKey(filepath);
+    if (!key)
+        return false;
+    return fs.existsSync(path.join(cacheDir, key));
 }
 function markCached(filepath, rootDir, content) {
     const cacheDir = getCacheDir(rootDir);
     if (!fs.existsSync(cacheDir)) {
         fs.mkdirSync(cacheDir, { recursive: true });
     }
-    const src = content !== undefined ? content : fs.readFileSync(filepath, 'utf-8');
-    const hash = fileHash(src);
-    const cacheFile = path.join(cacheDir, hash);
+    const key = content !== undefined ? contentKey(content) : statKey(filepath);
+    if (!key)
+        return;
+    const cacheFile = path.join(cacheDir, key);
     fs.writeFileSync(cacheFile, '');
 }
 function clearCache(rootDir) {

package/dist/checks/builtin-arg-count.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
+export declare const BUILTIN_FUNCTIONS: Set<string>;
 export declare function checkBuiltinArgCount(content: string, file: string): Issue[];
 //# sourceMappingURL=builtin-arg-count.d.ts.map

package/dist/checks/builtin-arg-count.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_FUNCTIONS = void 0;
 exports.checkBuiltinArgCount = checkBuiltinArgCount;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
+exports.BUILTIN_FUNCTIONS = new Set();
 const BUILTIN_ARITY = {
     // === Special forms & control flow ===
     if: { min: 2, max: 3 },
@@ -234,6 +236,9 @@ const BUILTIN_ARITY = {
     trace: { min: 1, max: 1 },
     untrace: { min: 1, max: 1 },
 };
+for (const key of Object.keys(BUILTIN_ARITY)) {
+    exports.BUILTIN_FUNCTIONS.add(key);
+}
 function checkBuiltinArgCount(content, file) {
     const issues = [];
     const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });

package/dist/checks/dangerous-calls.js

@@ -15,6 +15,7 @@ const PATTERNS = [
         functionCall: true,
     },
     { rule: 'command_shell', key: 'command_shell', messageKey: 'dangerous.command_shell', commandShell: true },
+    { rule: 'eval', key: 'eval', messageKey: 'dangerous.eval', functionCall: true },
 ];
 function isInQuote(node) {
     let cur = node.parent;

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

@@ -4,41 +4,165 @@ exports.checkGlobalFunctionNaming = checkGlobalFunctionNaming;
 const locale_1 = require("../locale");
 const utils_1 = require("../utils");
 const BUILTIN_FUNCTIONS = new Set([
-    'if', 'cond', 'when', 'unless', 'progn', 'setq', 'setq-e', 'while', 'repeat',
-    'foreach', 'lambda', 'function', 'quote', 'defun', 'defun-q', 'defmacro',
-    'let', 'let*', 'mapcar', 'apply', 'eval', 'load', 'require',
-    'car', 'cdr', 'cadr', 'cdar', 'caar', 'cddr', 'caddr', 'cadar',
-    'cons', 'list', 'append', 'reverse', 'nth', 'assoc', 'subst', 'member',
-    'length', 'numberp', 'stringp', 'listp', 'atom', 'null', 'not',
-    'eq', 'equal', '=', '/=', '<', '>', '<=', '>=',
-    '+', '-', '*', '/', '1+', '1-', 'abs', 'min', 'max',
-    'strcat', 'substr', 'strlen', 'strcase',
-    'itoa', 'atoi', 'rtos', 'atof', 'fix', 'float',
-    'princ', 'print', 'prin1', 'prompt', 'terpri',
-    'open', 'close', 'read-line', 'write-line', 'read-char', 'write-char',
-    'entmake', 'entmakex', 'entget', 'entmod', 'entdel', 'entlast', 'entnext',
-    'ssget', 'ssadd', 'ssdel', 'sslength', 'ssname', 'ssmemb',
-    'command', 'vl-cmdf', 'vlax-invoke', 'vlax-invoke-method',
-    'vlax-get', 'vlax-put', 'vlax-get-property', 'vlax-put-property',
-    'vlax-make-variant', 'vlax-variant-value',
-    'vlax-safearray', 'vlax-safearray-fill', 'vlax-safearray->list',
-    'vl-catch-all-apply', 'vl-catch-all-error-p', 'vl-catch-all-error-message',
-    'vl-load-com', 'vlax-dump-object', 'vlax-for',
-    'vl-registry-read', 'vl-registry-write', 'vl-registry-delete',
-    'vl-file-copy', 'vl-file-delete', 'vl-file-rename',
-    'vl-directory-files', 'vl-mkdir', 'vl-string->list', 'vl-list->string',
-    'vl-string-search', 'vl-string-subst',
-    'vl-string-position', 'vl-string-mismatch',
-    'vl-symbol-value', 'vl-symbol-name',
-    'vl-sort', 'vl-sort-i',
-    'vl-remove-if', 'vl-remove-if-not', 'vl-member-if', 'vl-some', 'vl-every',
-    'vl-position', 'vl-consp',
-    'startapp', 'quit', 'exit', '*error*',
-    'vla-get-', 'vla-put-', 'vlax-ename->vla-object', 'vlax-vla-object->ename',
-    'vlax-3d-point', 'vlax-tmatrix',
-    'vlax-curve-getarea', 'vlax-curve-getdistatparam', 'vlax-curve-getparamatdist',
-    'vlax-curve-getclosestpointto', 'vlax-curve-getstartpoint', 'vlax-curve-getendpoint',
-    'vlax-curve-getpointatdist', 'vlax-curve-getpointatparam',
+    'if',
+    'cond',
+    'when',
+    'unless',
+    'progn',
+    'setq',
+    'setq-e',
+    'while',
+    'repeat',
+    'foreach',
+    'lambda',
+    'function',
+    'quote',
+    'defun',
+    'defun-q',
+    'defmacro',
+    'let',
+    'let*',
+    'mapcar',
+    'apply',
+    'eval',
+    'load',
+    'require',
+    'car',
+    'cdr',
+    'cadr',
+    'cdar',
+    'caar',
+    'cddr',
+    'caddr',
+    'cadar',
+    'cons',
+    'list',
+    'append',
+    'reverse',
+    'nth',
+    'assoc',
+    'subst',
+    'member',
+    'length',
+    'numberp',
+    'stringp',
+    'listp',
+    'atom',
+    'null',
+    'not',
+    'eq',
+    'equal',
+    '=',
+    '/=',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '1+',
+    '1-',
+    'abs',
+    'min',
+    'max',
+    'strcat',
+    'substr',
+    'strlen',
+    'strcase',
+    'itoa',
+    'atoi',
+    'rtos',
+    'atof',
+    'fix',
+    'float',
+    'princ',
+    'print',
+    'prin1',
+    'prompt',
+    'terpri',
+    'open',
+    'close',
+    'read-line',
+    'write-line',
+    'read-char',
+    'write-char',
+    'entmake',
+    'entmakex',
+    'entget',
+    'entmod',
+    'entdel',
+    'entlast',
+    'entnext',
+    'ssget',
+    'ssadd',
+    'ssdel',
+    'sslength',
+    'ssname',
+    'ssmemb',
+    'command',
+    'vl-cmdf',
+    'vlax-invoke',
+    'vlax-invoke-method',
+    'vlax-get',
+    'vlax-put',
+    'vlax-get-property',
+    'vlax-put-property',
+    'vlax-make-variant',
+    'vlax-variant-value',
+    'vlax-safearray',
+    'vlax-safearray-fill',
+    'vlax-safearray->list',
+    'vl-catch-all-apply',
+    'vl-catch-all-error-p',
+    'vl-catch-all-error-message',
+    'vl-load-com',
+    'vlax-dump-object',
+    'vlax-for',
+    'vl-registry-read',
+    'vl-registry-write',
+    'vl-registry-delete',
+    'vl-file-copy',
+    'vl-file-delete',
+    'vl-file-rename',
+    'vl-directory-files',
+    'vl-mkdir',
+    'vl-string->list',
+    'vl-list->string',
+    'vl-string-search',
+    'vl-string-subst',
+    'vl-string-position',
+    'vl-string-mismatch',
+    'vl-symbol-value',
+    'vl-symbol-name',
+    'vl-sort',
+    'vl-sort-i',
+    'vl-remove-if',
+    'vl-remove-if-not',
+    'vl-member-if',
+    'vl-some',
+    'vl-every',
+    'vl-position',
+    'vl-consp',
+    'startapp',
+    'quit',
+    'exit',
+    '*error*',
+    'vla-get-',
+    'vla-put-',
+    'vlax-ename->vla-object',
+    'vlax-vla-object->ename',
+    'vlax-3d-point',
+    'vlax-tmatrix',
+    'vlax-curve-getarea',
+    'vlax-curve-getdistatparam',
+    'vlax-curve-getparamatdist',
+    'vlax-curve-getclosestpointto',
+    'vlax-curve-getstartpoint',
+    'vlax-curve-getendpoint',
+    'vlax-curve-getpointatdist',
+    'vlax-curve-getpointatparam',
 ]);
 function checkGlobalFunctionNaming(content, file) {
     const issues = [];

package/dist/checks/missing-princ.js

@@ -26,11 +26,11 @@ function checkMissingPrinc(content, file) {
         if (body.length === 0)
             continue;
         const lastForm = body[body.length - 1];
-        const isPrincCall = (lastForm.type === 'list' &&
+        const isPrincCall = lastForm.type === 'list' &&
             lastForm.children &&
             lastForm.children.length > 0 &&
             (0, parser_1.astIsSymbol)(lastForm.children[0]) &&
-            ['princ', 'print', 'prin1'].includes(lastForm.children[0].name || ''));
+            ['princ', 'print', 'prin1'].includes(lastForm.children[0].name || '');
         if (!isPrincCall) {
             issues.push({
                 file,

package/dist/checks/nth-usage.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
 export declare function checkNthUsage(content: string, file: string): Issue[];
+export declare function replaceNthUsage(line: string): string | null;
 //# sourceMappingURL=nth-usage.d.ts.map

package/dist/checks/nth-usage.js

@@ -1,17 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkNthUsage = checkNthUsage;
+exports.replaceNthUsage = replaceNthUsage;
 const locale_1 = require("../locale");
 const utils_1 = require("../utils");
+const NTH_RE = /\(nth\s+(\d+)\b/;
+const REPLACEMENTS = {
+    '0': 'car',
+    '1': 'cadr',
+    '2': 'caddr',
+    '3': 'cadddr',
+};
 function checkNthUsage(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 (/\(nth\s+0\b/.test(stripped)) {
+        const m = stripped.match(NTH_RE);
+        if (m && REPLACEMENTS[m[1]]) {
             issues.push({ file, line: i + 1, severity: 'warn', rule: 'nth_usage', message: (0, locale_1.t)('nth_usage') });
         }
     }
     return issues;
 }
+function replaceNthUsage(line) {
+    return line.replace(NTH_RE, (_, idx) => {
+        const replacement = REPLACEMENTS[idx];
+        return replacement ? `(${replacement} ` : `(nth ${idx} `;
+    });
+}
 //# sourceMappingURL=nth-usage.js.map

package/dist/cli/collector.d.ts

@@ -0,0 +1,7 @@
+import { LintConfig } from '../types';
+import { CliOptions } from './parser';
+declare function collectChangedFiles(rootDir: string, baseBranch: string): string[];
+export declare function collectFiles(rootDir: string, opts: CliOptions, config: LintConfig): string[];
+export declare function collectStagedFiles(rootDir: string): string[];
+export { collectChangedFiles };
+//# sourceMappingURL=collector.d.ts.map

package/dist/cli/collector.js

@@ -0,0 +1,154 @@
+"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.collectFiles = collectFiles;
+exports.collectStagedFiles = collectStagedFiles;
+exports.collectChangedFiles = collectChangedFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const GLOB_PLACEHOLDER = '\x00GLOB\x00';
+const GLOB_RE = new RegExp(GLOB_PLACEHOLDER, 'g');
+function* walkFiles(dir, rootDir, regex) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        let stat;
+        try {
+            stat = fs.statSync(fullPath);
+        }
+        catch {
+            continue;
+        }
+        const rel = path.relative(rootDir, fullPath).replace(/\\/g, '/');
+        if (rel.startsWith('..'))
+            continue;
+        if (stat.isDirectory()) {
+            yield* walkFiles(fullPath, rootDir, regex);
+        }
+        else if (stat.isFile()) {
+            if (regex.test(rel))
+                yield fullPath;
+        }
+    }
+}
+function collectChangedFiles(rootDir, baseBranch) {
+    try {
+        const output = (0, child_process_1.execSync)(`git diff --name-only --diff-filter=ACM ${baseBranch}`, {
+            cwd: rootDir,
+            encoding: 'utf-8',
+        });
+        return output
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l.endsWith('.lsp'))
+            .map(l => path.resolve(rootDir, l))
+            .filter(f => fs.existsSync(f));
+    }
+    catch {
+        return [];
+    }
+}
+function globFiles(pattern, rootDir) {
+    const regexStr = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*\//g, GLOB_PLACEHOLDER)
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.')
+        .replace(GLOB_RE, '(.*/)?');
+    const regex = new RegExp(`^${regexStr}$`);
+    return Array.from(walkFiles(rootDir, rootDir, regex));
+}
+function collectFiles(rootDir, opts, config) {
+    const files = new Set();
+    if (opts.src.length > 0 || opts.test.length > 0) {
+        for (const d of opts.src) {
+            for (const f of globFiles('**/*.lsp', path.resolve(rootDir, d))) {
+                files.add(f);
+            }
+        }
+        for (const d of opts.test) {
+            for (const f of globFiles('**/*.lsp', path.resolve(rootDir, d))) {
+                files.add(f);
+            }
+        }
+    }
+    else {
+        for (const pattern of config.source.globs) {
+            for (const f of globFiles(pattern, rootDir)) {
+                files.add(f);
+            }
+        }
+    }
+    const excludePatterns = config.source.exclude.map(e => {
+        const str = e
+            .replace(/\./g, '\\.')
+            .replace(/\*\*\//g, GLOB_PLACEHOLDER)
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(GLOB_RE, '(.*/)?');
+        return new RegExp(`^${str}$`);
+    });
+    return Array.from(files)
+        .filter(f => {
+        const rel = path.relative(rootDir, f).replace(/\\/g, '/');
+        for (const re of excludePatterns) {
+            if (re.test(rel))
+                return false;
+        }
+        return true;
+    })
+        .sort();
+}
+function collectStagedFiles(rootDir) {
+    const output = (0, child_process_1.execSync)('git diff --cached --name-only --diff-filter=ACM', {
+        cwd: rootDir,
+        encoding: 'utf-8',
+    });
+    return output
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l.endsWith('.lsp'))
+        .map(l => path.resolve(rootDir, l))
+        .filter(f => fs.existsSync(f));
+}
+//# sourceMappingURL=collector.js.map

package/dist/cli/parser.d.ts

@@ -0,0 +1,30 @@
+export interface CliOptions {
+    src: string[];
+    test: string[];
+    config?: string;
+    staged: boolean;
+    diff: boolean;
+    changed: string;
+    format: 'default' | 'json' | 'sarif' | 'html';
+    init: boolean;
+    installHook: boolean;
+    fix: boolean;
+    hookArgs: string;
+    cache: boolean;
+    clearCache: boolean;
+    parallel: boolean;
+    project: boolean;
+    watch: boolean;
+    help: boolean;
+    version: boolean;
+    formatCode: boolean;
+    formatCheck: boolean;
+    sbcl: boolean;
+    docs: boolean;
+    listRules: boolean;
+    explain: string;
+    dryRun: boolean;
+    maxWarnings: number;
+}
+export declare function parseArgs(): CliOptions;
+//# sourceMappingURL=parser.d.ts.map