@atlisp/lint 0.2.11 → 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": {
@@ -196,6 +209,23 @@
         "walk_exclude": { "type": "array", "items": { "type": "string" }, "default": [".vscode", "vendor", ".git"] },
         "defmacro_allow_files": { "type": "array", "items": { "type": "string" }, "default": ["compat-cl"] }
       }
+    },
+    "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)"
+        }
+      }
     }
   }
 }

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

@@ -6,4 +6,11 @@ export declare function checkDanglingDefun(file: string, allDefuns: Map<string,
     file: string;
     line: number;
 }[]>): Issue[];
+export declare function checkDanglingDefunFromDefs(localDefuns: {
+    name: string;
+    line: number;
+}[], allReferences: Map<string, {
+    file: string;
+    line: number;
+}[]>, file: string): Issue[];
 //# sourceMappingURL=dangling-defun.d.ts.map

package/dist/checks/dangling-defun.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkDanglingDefun = checkDanglingDefun;
+exports.checkDanglingDefunFromDefs = checkDanglingDefunFromDefs;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const fs = __importStar(require("fs"));
@@ -64,4 +65,22 @@ function checkDanglingDefun(file, allDefuns, allReferences) {
     }
     return issues;
 }
+function checkDanglingDefunFromDefs(localDefuns, allReferences, file) {
+    const issues = [];
+    for (const defun of localDefuns) {
+        const refs = allReferences.get(defun.name) || [];
+        const calledElsewhere = refs.some(r => r.file !== file);
+        const calledLocally = refs.some(r => r.file === file);
+        if (!calledLocally && !calledElsewhere) {
+            issues.push({
+                file,
+                line: defun.line,
+                severity: 'warn',
+                rule: 'dangling_defun',
+                message: (0, locale_1.t)('dangling_defun', defun.name),
+            });
+        }
+    }
+    return issues;
+}
 //# sourceMappingURL=dangling-defun.js.map

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/checks/unused-package-dep.d.ts

@@ -1,3 +1,4 @@
 import { Issue } from '../types';
 export declare function checkUnusedPackageDep(file: string): Issue[];
+export declare function checkUnusedPackageDepFromContent(file: string, content: string): Issue[];
 //# sourceMappingURL=unused-package-dep.d.ts.map

package/dist/checks/unused-package-dep.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkUnusedPackageDep = checkUnusedPackageDep;
+exports.checkUnusedPackageDepFromContent = checkUnusedPackageDepFromContent;
 const locale_1 = require("../locale");
 const parser_1 = require("@atlisp/parser");
 const fs = __importStar(require("fs"));
@@ -90,4 +91,56 @@ function checkUnusedPackageDep(file) {
     }
     return issues;
 }
+function checkUnusedPackageDepFromContent(file, content) {
+    const issues = [];
+    const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+    const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
+    if (inPackageNodes.length === 0)
+        return issues;
+    const allPackages = new Set();
+    for (const node of inPackageNodes) {
+        if (node.children && node.children.length >= 2 && (0, parser_1.astIsSymbol)(node.children[1])) {
+            allPackages.add(node.children[1].name);
+        }
+    }
+    const usedSymbols = new Set();
+    const allLists = (0, parser_1.astFindAll)(ast, n => n.type === 'list');
+    for (const node of allLists) {
+        if (!node.children || node.children.length === 0)
+            continue;
+        const car = node.children[0];
+        if (car.type === 'symbol' && car.name) {
+            const parts = car.name.split(':');
+            if (parts.length === 2 && parts[0] && parts[1]) {
+                usedSymbols.add(parts[0]);
+            }
+        }
+        for (let i = 1; i < node.children.length; i++) {
+            const child = node.children[i];
+            if (child.type === 'symbol' && child.name) {
+                const parts = child.name.split(':');
+                if (parts.length === 2 && parts[0] && parts[1]) {
+                    usedSymbols.add(parts[0]);
+                }
+            }
+        }
+    }
+    const mainPackage = inPackageNodes.length > 0 && inPackageNodes[0].children && inPackageNodes[0].children[1]
+        ? inPackageNodes[0].children[1].name || ''
+        : '';
+    allPackages.delete(mainPackage);
+    for (const pkg of allPackages) {
+        if (!usedSymbols.has(pkg)) {
+            const node = inPackageNodes.find(n => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === pkg);
+            issues.push({
+                file,
+                line: node ? node.pos.line : 1,
+                severity: 'warn',
+                rule: 'unused_package_dep',
+                message: (0, locale_1.t)('unused_package_dep', pkg),
+            });
+        }
+    }
+    return issues;
+}
 //# sourceMappingURL=unused-package-dep.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