cspell 5.13.3 → 5.15.0

package/README.md

@@ -56,6 +56,12 @@ cspell lint "src/**/*.js"
 cspell "**"
 ```
 
+**Git: Check Only Changed Files**
+
+```sh
+ git diff --name-only | npx cspell --file-list stdin
+```
+
 ## Command: `lint` -- Spell Checking
 
 The `lint` command is used for spell checking files.
@@ -69,7 +75,7 @@ cspell lint --help
 ### Options
 
 ```text
-Usage: cspell lint [options] [files...]
+Usage: cspell lint [options] [globs...]
 
 Check spelling
 
@@ -77,8 +83,8 @@ Options:
   -c, --config <cspell.json>   Configuration file to use.  By default cspell
                                looks for cspell.json in the current directory.
 
-  -v, --verbose                display more information about the files being
-                               checked and the configuration
+  -v, --verbose                Display more information about the files being
+                               checked and the configuration.
 
   --locale <locale>            Set language locales. i.e. "en,fr" for English
                                and French, or "en-GB" for British English.
@@ -92,28 +98,30 @@ Options:
   -u, --unique                 Only output the first instance of a word not
                                found in the dictionaries.
 
-  --debug                      Output information useful for debugging
-                               cspell.json files.
-
   -e, --exclude <glob>         Exclude files matching the glob pattern. This
                                option can be used multiple times to add
                                multiple globs.
 
+  --file-list <path or stdin>  Specify a list of files to be spell checked. The
+                               list is filtered against the glob file patterns.
+                               Note: the format is 1 file path per line.
+
   --no-issues                  Do not show the spelling errors.
   --no-progress                Turn off progress messages
-  --no-summary                 Turn off summary message in console
-  -s, --silent                 Silent mode, suppress error messages
+  --no-summary                 Turn off summary message in console.
+  -s, --silent                 Silent mode, suppress error messages.
   -r, --root <root folder>     Root directory, defaults to current directory.
   --relative                   Issues are displayed relative to root.
   --show-context               Show the surrounding text around an issue.
   --show-suggestions           Show spelling suggestions.
-  --no-must-find-files         Do not error if no files are found
+  --no-must-find-files         Do not error if no files are found.
 
-  --cache                      Only check changed files (default: false)
-  --cache-strategy <strategy>  Strategy to use for detecting changed files
+  --cache                      Use cache to only check changed files.
+  --no-cache                   Do not use cache.
+  --cache-strategy <strategy>  Strategy to use for detecting changed files.
                                (choices: "metadata", "content")
 
-  --cache-location <path>      Path to the cache file or directory (default:
+  --cache-location <path>      Path to the cache file or directory. (default:
                                ".cspellcache")
 
   --dot                        Include files and directories starting with `.`
@@ -128,7 +136,9 @@ Options:
                                root.
 
   --no-color                   Turn off color.
-  --color                      Force color
+  --color                      Force color.
+  --debug                      Output information useful for debugging
+                               cspell.json files.
   -h, --help                   display help for command
 
 
@@ -196,8 +206,7 @@ npm install -SD cspell
 ```
 #!/bin/sh
 
-files=$(git diff --cached --name-only)
-exec npx cspell -- --no-summary $files
+exec git diff --cached --name-only | npx cspell -- --no-summary --no-progress --no-must-find-files --file-list stdin
 ```
 
 ## Requirements

package/dist/app.d.ts

@@ -1,5 +1,5 @@
 import * as commander from 'commander';
-export { LinterCliOptions as Options } from './commandLint';
+export { LinterCliOptions as Options } from './options';
 export { CheckFailed } from './util/errors';
 export declare function run(program?: commander.Command, argv?: string[]): Promise<void>;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -22,19 +22,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = exports.CheckFailed = void 0;
 const commander = __importStar(require("commander"));
 const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
 const commandCheck_1 = require("./commandCheck");
 const commandLink_1 = require("./commandLink");
 const commandLint_1 = require("./commandLint");
 const commandTrace_1 = require("./commandTrace");
+const errors_1 = require("./util/errors");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const npmPackage = require(path.join(__dirname, '..', 'package.json'));
-var errors_1 = require("./util/errors");
-Object.defineProperty(exports, "CheckFailed", { enumerable: true, get: function () { return errors_1.CheckFailed; } });
+var errors_2 = require("./util/errors");
+Object.defineProperty(exports, "CheckFailed", { enumerable: true, get: function () { return errors_2.CheckFailed; } });
 async function run(program, argv) {
     const prog = program || commander.program;
     const args = argv || process.argv;
     prog.exitOverride();
     prog.version(npmPackage.version).description('Spelling Checker for Code').name('cspell');
+    if (!semver.satisfies(process.versions.node, npmPackage.engines.node)) {
+        throw new errors_1.ApplicationError(`Unsupported NodeJS version (${process.versions.node}); ${npmPackage.engines.node} is required`);
+    }
     (0, commandLint_1.commandLint)(prog);
     (0, commandTrace_1.commandTrace)(prog);
     (0, commandCheck_1.commandCheck)(prog);

package/dist/application.d.ts

@@ -5,7 +5,7 @@ import { BaseOptions, LinterOptions, TraceOptions } from './options';
 export { IncludeExcludeFlag } from 'cspell-lib';
 export type { TraceResult } from 'cspell-lib';
 export declare type AppError = NodeJS.ErrnoException;
-export declare function lint(files: string[], options: LinterOptions, emitters: CSpellReporter): Promise<RunResult>;
+export declare function lint(fileGlobs: string[], options: LinterOptions, emitters: CSpellReporter): Promise<RunResult>;
 export declare function trace(words: string[], options: TraceOptions): Promise<TraceResult[]>;
 export declare type CheckTextResult = CheckTextInfo;
 export declare function checkText(filename: string, options: BaseOptions): Promise<CheckTextResult>;

package/dist/application.js

@@ -28,8 +28,8 @@ const lint_1 = require("./lint");
 const util = __importStar(require("./util/util"));
 var cspell_lib_2 = require("cspell-lib");
 Object.defineProperty(exports, "IncludeExcludeFlag", { enumerable: true, get: function () { return cspell_lib_2.IncludeExcludeFlag; } });
-function lint(files, options, emitters) {
-    const cfg = new lint_1.LintRequest(files, options, emitters);
+function lint(fileGlobs, options, emitters) {
+    const cfg = new lint_1.LintRequest(fileGlobs, options, emitters);
     return (0, lint_1.runLint)(cfg);
 }
 exports.lint = lint;

package/dist/cli-reporter.d.ts

@@ -1,9 +1,12 @@
 import type { CSpellReporter, Issue } from '@cspell/cspell-types';
-import { Options } from './app';
+import { LinterCliOptions } from './options';
 export interface ReporterIssue extends Issue {
     filename: string;
 }
-export declare function getReporter(options: Options): CSpellReporter;
+export interface ReporterOptions extends Pick<LinterCliOptions, 'debug' | 'issues' | 'legacy' | 'progress' | 'relative' | 'root' | 'showContext' | 'showSuggestions' | 'silent' | 'summary' | 'verbose' | 'wordsOnly'> {
+    fileGlobs: string[];
+}
+export declare function getReporter(options: ReporterOptions): CSpellReporter;
 declare function formatIssue(templateStr: string, issue: ReporterIssue, maxIssueTextWidth: number): string;
 export declare const __testing__: {
     formatIssue: typeof formatIssue;

package/dist/cli-reporter.js

@@ -98,7 +98,7 @@ function getReporter(options) {
                 : options.showSuggestions
                     ? templateIssueWithSuggestions
                     : templateIssue;
-    const { files, silent, summary, issues, progress, verbose, debug } = options;
+    const { fileGlobs, silent, summary, issues, progress, verbose, debug } = options;
     const emitters = {
         Debug: !silent && debug ? (s) => console.info(chalk.cyan(s)) : nullEmitter,
         Info: !silent && verbose ? (s) => console.info(chalk.yellow(s)) : nullEmitter,
@@ -121,7 +121,7 @@ function getReporter(options) {
         };
     }
     const resultEmitter = (result) => {
-        if (!files.length && !result.files) {
+        if (!fileGlobs.length && !result.files) {
             return;
         }
         console.error('CSpell: Files checked: %d, Issues found: %d in %d files', result.files, result.issues, result.filesWithIssues.size);

package/dist/commandLint.d.ts

@@ -1,17 +1,3 @@
 import { Command } from 'commander';
-import { LinterOptions } from './options';
-export interface LinterCliOptions extends LinterOptions {
-    files: string[];
-    legacy?: boolean;
-    summary: boolean;
-    issues: boolean;
-    silent: boolean;
-    mustFindFiles: boolean;
-    progress?: boolean;
-    /**
-     * issues are shown with a relative path to the root or `cwd`
-     */
-    relative?: boolean;
-}
 export declare function commandLint(prog: Command): Command;
 //# sourceMappingURL=commandLint.d.ts.map

package/dist/commandLint.js

@@ -47,50 +47,54 @@ function commandLint(prog) {
     spellCheckCommand
         .description('Check spelling')
         .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
-        .option('-v, --verbose', 'display more information about the files being checked and the configuration')
+        .option('-v, --verbose', 'Display more information about the files being checked and the configuration.')
         .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
         .option('--language-id <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
         .addOption(new commander_1.Option('--languageId <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"').hideHelp())
         .option('--words-only', 'Only output the words not found in the dictionaries.')
         .addOption(new commander_1.Option('--wordsOnly', 'Only output the words not found in the dictionaries.').hideHelp())
         .option('-u, --unique', 'Only output the first instance of a word not found in the dictionaries.')
-        .option('--debug', 'Output information useful for debugging cspell.json files.')
         .option('-e, --exclude <glob>', 'Exclude files matching the glob pattern. This option can be used multiple times to add multiple globs. ', collect)
+        .option('--file-list <path or stdin>', 'Specify a list of files to be spell checked.' +
+        ' The list is filtered against the glob file patterns.' +
+        ' Note: the format is 1 file path per line.', collect)
         .option('--no-issues', 'Do not show the spelling errors.')
         .option('--no-progress', 'Turn off progress messages')
-        .option('--no-summary', 'Turn off summary message in console')
-        .option('-s, --silent', 'Silent mode, suppress error messages')
+        .option('--no-summary', 'Turn off summary message in console.')
+        .option('-s, --silent', 'Silent mode, suppress error messages.')
         .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
         .option('--relative', 'Issues are displayed relative to root.')
         .option('--show-context', 'Show the surrounding text around an issue.')
         .option('--show-suggestions', 'Show spelling suggestions.')
-        .addOption(new commander_1.Option('--must-find-files', 'Error if no files are found').default(true).hideHelp())
-        .option('--no-must-find-files', 'Do not error if no files are found')
+        .addOption(new commander_1.Option('--must-find-files', 'Error if no files are found.').default(true).hideHelp())
+        .option('--no-must-find-files', 'Do not error if no files are found.')
         // The following options are planned features
         // .option('-w, --watch', 'Watch for any changes to the matching files and report any errors')
         // .option('--force', 'Force the exit value to always be 0')
-        .option('--legacy', 'Legacy output')
+        .addOption(new commander_1.Option('--legacy', 'Legacy output').hideHelp())
         .addOption(new commander_1.Option('--local <local>', 'Deprecated -- Use: --locale').hideHelp())
-        .option('--cache', 'Only check changed files', false)
-        .addOption(new commander_1.Option('--cache-strategy <strategy>', 'Strategy to use for detecting changed files').choices([
+        .option('--cache', 'Use cache to only check changed files.')
+        .option('--no-cache', 'Do not use cache.')
+        .addOption(new commander_1.Option('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.').choices([
         'metadata',
         'content',
     ]))
-        .option('--cache-location <path>', `Path to the cache file or directory`, cache_1.DEFAULT_CACHE_LOCATION)
+        .option('--cache-location <path>', `Path to the cache file or directory. (default: "${cache_1.DEFAULT_CACHE_LOCATION}")`)
         .option('--dot', 'Include files and directories starting with `.` (period) when matching globs.')
         .option('--gitignore', 'Ignore files matching glob patterns found in .gitignore files.')
         .option('--no-gitignore', 'Do NOT use .gitignore files.')
         .option('--gitignore-root <path>', 'Prevent searching for .gitignore files past root.', collect)
         .option('--no-color', 'Turn off color.')
-        .option('--color', 'Force color')
+        .option('--color', 'Force color.')
+        .option('--debug', 'Output information useful for debugging cspell.json files.')
         .addHelpText('after', usage)
-        .arguments('[files...]')
-        .action((files, options) => {
-        options.files = files;
-        const { mustFindFiles } = options;
-        const cliReporter = (0, cli_reporter_1.getReporter)(options);
-        return App.lint(files, options, cliReporter).then((result) => {
-            if (!files.length && !result.files) {
+        .arguments('[globs...]')
+        .action((fileGlobs, options) => {
+        const { mustFindFiles, fileList } = options;
+        const cliReporter = (0, cli_reporter_1.getReporter)({ ...options, fileGlobs });
+        const lintOptions = { ...options, fileLists: fileList };
+        return App.lint(fileGlobs, lintOptions, cliReporter).then((result) => {
+            if (!fileGlobs.length && !result.files && !result.errors && !fileList) {
                 spellCheckCommand.outputHelp();
                 throw new errors_1.CheckFailed('outputHelp', 1);
             }

package/dist/fileHelper.d.ts

@@ -33,4 +33,18 @@ export declare function readFile(filename: string, encoding?: string): Promise<s
  */
 export declare function findFiles(globPatterns: string[], options: GlobOptions): Promise<string[]>;
 export declare function calcFinalConfigInfo(configInfo: ConfigInfo, settingsFromCommandLine: CSpellUserSettings, filename: string, text: string): FileConfigInfo;
+/**
+ * Read
+ * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
+ *   file will be resolved relative to the containing file.
+ * @returns - a list of files to be processed.
+ */
+export declare function readFileListFiles(listFiles: string[]): Promise<string[]>;
+/**
+ * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
+ * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
+ *   file will be resolved relative to the containing file.
+ * @returns - a list of files to be processed.
+ */
+export declare function readFileListFile(listFile: string): Promise<string[]>;
 //# sourceMappingURL=fileHelper.d.ts.map

package/dist/fileHelper.js

@@ -22,13 +22,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcFinalConfigInfo = exports.findFiles = exports.readFile = exports.readFileInfo = exports.fileInfoToDocument = exports.readConfig = void 0;
+exports.readFileListFile = exports.readFileListFiles = exports.calcFinalConfigInfo = exports.findFiles = exports.readFile = exports.readFileInfo = exports.fileInfoToDocument = exports.readConfig = void 0;
 const cspell = __importStar(require("cspell-lib"));
 const fsp = __importStar(require("fs-extra"));
 const get_stdin_1 = __importDefault(require("get-stdin"));
 const glob_1 = require("./util/glob");
 const path = __importStar(require("path"));
 const cspell_lib_1 = require("cspell-lib");
+const errors_1 = require("./util/errors");
 const UTF8 = 'utf8';
 const STDIN = 'stdin';
 async function readConfig(configFile, root) {
@@ -61,10 +62,7 @@ function readFileInfo(filename, encoding = UTF8) {
     return pText.then((text) => ({ text, filename }), (error) => {
         return error.code === 'EISDIR'
             ? Promise.resolve({ text: '', filename })
-            : Promise.reject({
-                ...error,
-                message: `Error reading file: "${filename}"`,
-            });
+            : Promise.reject((0, errors_1.toApplicationError)(error, `Error reading file: "${filename}"`));
     });
 }
 exports.readFileInfo = readFileInfo;
@@ -98,4 +96,44 @@ function calcFinalConfigInfo(configInfo, settingsFromCommandLine, filename, text
     };
 }
 exports.calcFinalConfigInfo = calcFinalConfigInfo;
+/**
+ * Read
+ * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
+ *   file will be resolved relative to the containing file.
+ * @returns - a list of files to be processed.
+ */
+async function readFileListFiles(listFiles) {
+    return flatten(await Promise.all(listFiles.map(readFileListFile)));
+}
+exports.readFileListFiles = readFileListFiles;
+/**
+ * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
+ * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
+ *   file will be resolved relative to the containing file.
+ * @returns - a list of files to be processed.
+ */
+async function readFileListFile(listFile) {
+    try {
+        const relTo = path.resolve(path.dirname(listFile));
+        const content = await readFile(listFile);
+        const lines = content
+            .split('\n')
+            .map((a) => a.trim())
+            .filter((a) => !!a)
+            .map((file) => path.resolve(relTo, file));
+        return lines;
+    }
+    catch (err) {
+        throw (0, errors_1.toApplicationError)(err, `Error reading file list from: "${listFile}"`);
+    }
+}
+exports.readFileListFile = readFileListFile;
+function flatten(fileLists) {
+    function* f() {
+        for (const list of fileLists) {
+            yield* list;
+        }
+    }
+    return [...f()];
+}
 //# sourceMappingURL=fileHelper.js.map

package/dist/lint/LintRequest.d.ts

@@ -2,7 +2,7 @@ import type { CSpellReporter, Issue } from '@cspell/cspell-types';
 import { LinterOptions } from '../options';
 import { GlobSrcInfo } from '../util/glob';
 export declare class LintRequest {
-    readonly files: string[];
+    readonly fileGlobs: string[];
     readonly options: LinterOptions;
     readonly reporter: CSpellReporter;
     readonly uniqueFilter: (issue: Issue) => boolean;
@@ -12,6 +12,7 @@ export declare class LintRequest {
     readonly root: string;
     readonly showContext: number;
     readonly enableGlobDot: boolean | undefined;
-    constructor(files: string[], options: LinterOptions, reporter: CSpellReporter);
+    readonly fileLists: string[];
+    constructor(fileGlobs: string[], options: LinterOptions, reporter: CSpellReporter);
 }
 //# sourceMappingURL=LintRequest.d.ts.map

package/dist/lint/LintRequest.js

@@ -25,8 +25,8 @@ const glob_1 = require("../util/glob");
 const util = __importStar(require("../util/util"));
 const defaultContextRange = 20;
 class LintRequest {
-    constructor(files, options, reporter) {
-        this.files = files;
+    constructor(fileGlobs, options, reporter) {
+        this.fileGlobs = fileGlobs;
         this.options = options;
         this.reporter = reporter;
         this.root = path.resolve(options.root || process.cwd());
@@ -37,6 +37,7 @@ class LintRequest {
         this.uniqueFilter = options.unique ? util.uniqueFilterFnGenerator((issue) => issue.text) : () => true;
         this.showContext =
             options.showContext === true ? defaultContextRange : options.showContext ? options.showContext : 0;
+        this.fileLists = options.fileLists || [];
     }
 }
 exports.LintRequest = LintRequest;

package/dist/lint/lint.js

@@ -23,6 +23,7 @@ exports.runLint = void 0;
 const cspell_types_1 = require("@cspell/cspell-types");
 const commentJson = __importStar(require("comment-json"));
 const cspell_gitignore_1 = require("cspell-gitignore");
+const cspell_glob_1 = require("cspell-glob");
 const cspell = __importStar(require("cspell-lib"));
 const path = __importStar(require("path"));
 const util_1 = require("util");
@@ -36,6 +37,7 @@ const timer_1 = require("../util/timer");
 const util = __importStar(require("../util/util"));
 async function runLint(cfg) {
     let { reporter } = cfg;
+    const { fileLists } = cfg;
     cspell.setLogger(getLoggerFromReporter(reporter));
     const configErrors = new Set();
     const lintResult = await run();
@@ -43,7 +45,7 @@ async function runLint(cfg) {
     return lintResult;
     async function processFile(filename, configInfo, cache) {
         var _a, _b, _c, _d;
-        const cachedResult = await cache.getCachedLintResults(filename, configInfo);
+        const cachedResult = await cache.getCachedLintResults(filename);
         if (cachedResult) {
             reporter.debug(`Filename: ${filename}, using cache`);
             return cachedResult;
@@ -84,7 +86,8 @@ async function runLint(cfg) {
         reporter.info(`Checked: ${filename}, File type: ${config.languageId}, Language: ${config.language} ... Issues: ${result.issues.length} ${elapsed}S`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Config file Used: ${spellResult.localConfigFilepath || configInfo.source}`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Dictionaries Used: ${dictionaries.join(', ')}`, cspell_types_1.MessageTypes.Info);
-        cache.setCachedLintResults(result, configInfo);
+        const dep = calcDependencies(config);
+        cache.setCachedLintResults(result, dep.files);
         return result;
     }
     function mapIssue({ doc: _, ...tdo }) {
@@ -93,9 +96,10 @@ async function runLint(cfg) {
             : { text: tdo.line.text.trimEnd(), offset: tdo.line.offset };
         return { ...tdo, context };
     }
-    async function processFiles(files, configInfo, fileCount) {
+    async function processFiles(files, configInfo, cacheSettings) {
+        const fileCount = files.length;
         const status = runResult();
-        const cache = (0, cache_1.createCache)({ ...cfg.options, root: cfg.root });
+        const cache = (0, cache_1.createCache)(cacheSettings);
         const emitProgress = (filename, fileNum, result) => reporter.progress({
             type: 'ProgressFileComplete',
             fileNum,
@@ -115,12 +119,8 @@ async function runLint(cfg) {
         }
         for await (const fileP of loadAndProcessFiles()) {
             const { filename, fileNum, result } = await fileP;
-            if (!result.fileInfo.text === undefined) {
-                status.files += result.cached ? 1 : 0;
-                emitProgress(filename, fileNum, result);
-                continue;
-            }
             status.files += 1;
+            status.cachedFiles += result.cached ? 1 : 0;
             emitProgress(filename, fileNum, result);
             // Show the spelling errors after emitting the progress.
             result.issues.filter(cfg.uniqueFilter).forEach((issue) => reporter.issue(issue));
@@ -134,6 +134,10 @@ async function runLint(cfg) {
         cache.reconcile();
         return status;
     }
+    function calcDependencies(config) {
+        const { configFiles, dictionaryFiles } = cspell.extractDependencies(config);
+        return { files: configFiles.concat(dictionaryFiles) };
+    }
     async function reportConfigurationErrors(config) {
         const errors = cspell.extractImportErrors(config);
         let count = 0;
@@ -175,7 +179,7 @@ async function runLint(cfg) {
         const useGitignore = (_b = (_a = cfg.options.gitignore) !== null && _a !== void 0 ? _a : configInfo.config.useGitignore) !== null && _b !== void 0 ? _b : false;
         const gitignoreRoots = (_c = cfg.options.gitignoreRoot) !== null && _c !== void 0 ? _c : configInfo.config.gitignoreRoot;
         const gitIgnore = useGitignore ? await generateGitIgnore(gitignoreRoots) : undefined;
-        const cliGlobs = cfg.files;
+        const cliGlobs = cfg.fileGlobs;
         const allGlobs = cliGlobs.length ? cliGlobs : configInfo.config.files || [];
         const combinedGlobs = (0, glob_1.normalizeGlobsToRoot)(allGlobs, cfg.root, false);
         const cliExcludeGlobs = (0, glob_1.extractPatterns)(cfg.excludes).map((p) => p.glob);
@@ -183,7 +187,8 @@ async function runLint(cfg) {
         const includeGlobs = combinedGlobs.filter((g) => !g.startsWith('!'));
         const excludeGlobs = combinedGlobs.filter((g) => g.startsWith('!')).concat(normalizedExcludes);
         const fileGlobs = includeGlobs;
-        if (!fileGlobs.length) {
+        const hasFileLists = !!fileLists.length;
+        if (!fileGlobs.length && !hasFileLists) {
             // Nothing to do.
             return runResult();
         }
@@ -208,10 +213,20 @@ async function runLint(cfg) {
         if (enableGlobDot !== undefined) {
             globOptions.dot = enableGlobDot;
         }
-        const foundFiles = await (0, fileHelper_1.findFiles)(fileGlobs, globOptions);
-        const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
-        const files = filterFiles(filtered, globMatcher);
-        return processFiles(files, configInfo, files.length);
+        try {
+            const cacheSettings = await (0, cache_1.calcCacheSettings)(configInfo.config, cfg.options, root);
+            const foundFiles = await (hasFileLists
+                ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
+                : (0, fileHelper_1.findFiles)(fileGlobs, globOptions));
+            const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
+            const files = filterFiles(filtered, globMatcher);
+            return await processFiles(files, configInfo, cacheSettings);
+        }
+        catch (e) {
+            const err = (0, errors_1.toApplicationError)(e);
+            reporter.error('Linter', err);
+            return runResult({ errors: 1 });
+        }
     }
     function header(files, cliExcludes) {
         const formattedFiles = files.length > 100 ? files.slice(0, 100).concat(['...']) : files;
@@ -227,13 +242,13 @@ Options:
     unique:    ${yesNo(!!cfg.options.unique)}
 `, cspell_types_1.MessageTypes.Info);
     }
-    function isExcluded(filename, globMatcher) {
+    function isExcluded(filename, globMatcherExclude) {
         if (cspell.isBinaryFile(vscode_uri_1.URI.file(filename))) {
             return true;
         }
         const { root } = cfg;
         const absFilename = path.resolve(root, filename);
-        const r = globMatcher.matchEx(absFilename);
+        const r = globMatcherExclude.matchEx(absFilename);
         if (r.matched) {
             const { glob, source } = extractGlobSource(r.pattern);
             reporter.info(`Excluded File: ${path.relative(root, absFilename)}; Excluded by ${glob} from ${source}`, cspell_types_1.MessageTypes.Info);
@@ -247,14 +262,14 @@ Options:
             source,
         };
     }
-    function filterFiles(files, globMatcher) {
-        const patterns = globMatcher.patterns;
+    function filterFiles(files, globMatcherExclude) {
+        const patterns = globMatcherExclude.patterns;
         const excludeInfo = patterns
             .map(extractGlobSource)
             .map(({ glob, source }) => `Glob: ${glob} from ${source}`)
             .filter(util.uniqueFn());
         reporter.info(`Exclusion Globs: \n    ${excludeInfo.join('\n    ')}\n`, cspell_types_1.MessageTypes.Info);
-        const result = files.filter(util.uniqueFn()).filter((filename) => !isExcluded(filename, globMatcher));
+        const result = files.filter(util.uniqueFn()).filter((filename) => !isExcluded(filename, globMatcherExclude));
         return result;
     }
 }
@@ -288,8 +303,8 @@ function extractContext(tdo, contextRange) {
     return context;
 }
 function runResult(init = {}) {
-    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0 } = init;
-    return { files, filesWithIssues, issues, errors };
+    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
+    return { files, filesWithIssues, issues, errors, cachedFiles };
 }
 function yesNo(value) {
     return value ? 'Yes' : 'No';
@@ -323,4 +338,14 @@ async function generateGitIgnore(roots) {
     }
     return new cspell_gitignore_1.GitIgnore(root === null || root === void 0 ? void 0 : root.map((p) => path.resolve(p)));
 }
+async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
+    includeGlobPatterns = includeGlobPatterns.length ? includeGlobPatterns : ['**'];
+    const options = { root, mode: 'include' };
+    if (dot !== undefined) {
+        options.dot = dot;
+    }
+    const globMatcher = new cspell_glob_1.GlobMatcher(includeGlobPatterns, options);
+    const files = await (0, fileHelper_1.readFileListFiles)(fileListFiles);
+    return files.filter((file) => globMatcher.match(file));
+}
 //# sourceMappingURL=lint.js.map

package/dist/options.d.ts

@@ -48,15 +48,49 @@ export interface LinterOptions extends BaseOptions, CacheOptions {
      * Stop searching for a `.gitignore`s when a root is reached.
      */
     gitignoreRoot?: string | string[];
+    /**
+     * List of files that contains the paths to files to be spell checked.
+     * The files in the lists will be filtered against the glob patterns.
+     * - an entry of `stdin` means to read the file list from **`stdin`**
+     */
+    fileLists?: string[] | undefined;
 }
 export interface TraceOptions extends BaseOptions {
     allowCompoundWords?: boolean;
     ignoreCase?: boolean;
 }
 export interface BaseOptions {
+    /**
+     * Path to configuration file.
+     */
     config?: string;
+    /**
+     * Programming Language ID.
+     */
     languageId?: string;
+    /**
+     * Locale to use.
+     */
     locale?: string;
+    /**
+     * @deprecated
+     */
     local?: string;
 }
+export interface LinterCliOptions extends Omit<LinterOptions, 'fileLists'> {
+    legacy?: boolean;
+    summary: boolean;
+    issues: boolean;
+    silent: boolean;
+    mustFindFiles: boolean;
+    progress?: boolean;
+    /**
+     * issues are shown with a relative path to the root or `cwd`
+     */
+    relative?: boolean;
+    /**
+     * List of file paths to files that contains a list of files to be spell checked.
+     */
+    fileList?: string[];
+}
 //# sourceMappingURL=options.d.ts.map

package/dist/util/cache/CSpellLintResultCache.d.ts

@@ -1,13 +1,13 @@
-import { ConfigInfo, FileResult } from '../../fileHelper';
+import { FileResult } from '../../fileHelper';
 export interface CSpellLintResultCache {
     /**
      * Retrieve cached lint results for a given file name, if present in the cache.
      */
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
     /**
      * Set the cached lint results.
      */
-    setCachedLintResults(result: FileResult, configInfo: ConfigInfo): void;
+    setCachedLintResults(result: FileResult, dependsUponFiles: string[]): void;
     /**
      * Persists the in-memory cache to disk.
      */

package/dist/util/cache/CacheOptions.d.ts

@@ -1,3 +1,4 @@
+import type { CacheStrategy } from '@cspell/cspell-types';
 export interface CacheOptions {
     /**
      * Store the info about processed files in order to only operate on the changed ones.
@@ -12,6 +13,6 @@ export interface CacheOptions {
     /**
      * Strategy to use for detecting changed files, default: metadata
      */
-    cacheStrategy?: 'metadata' | 'content';
+    cacheStrategy?: CacheStrategy;
 }
 //# sourceMappingURL=CacheOptions.d.ts.map

package/dist/util/cache/DiskCache.d.ts

@@ -1,13 +1,34 @@
-import type { ConfigInfo, FileResult } from '../../fileHelper';
+import type { FileDescriptor } from 'file-entry-cache';
+import type { FileResult } from '../../fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
+export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs'>;
+/**
+ * This is the data cached.
+ * Property names are short to help keep the cache file size small.
+ */
+interface CachedData {
+    /** results */
+    r: CachedFileResult;
+    /** dependencies */
+    d: string[];
+}
+interface CSpellCachedMetaData {
+    data?: CachedData;
+}
+export declare type CSpellCacheMeta = (FileDescriptor['meta'] & CSpellCachedMetaData) | undefined;
 /**
  * Caches cspell results on disk
  */
 export declare class DiskCache implements CSpellLintResultCache {
     private fileEntryCache;
+    private changedDependencies;
+    private knownDependencies;
     constructor(cacheFileLocation: string, useCheckSum: boolean);
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, configInfo: ConfigInfo): void;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
+    private cacheDependencies;
+    private checkDependencies;
 }
+export {};
 //# sourceMappingURL=DiskCache.d.ts.map

package/dist/util/cache/DiskCache.js

@@ -1,53 +1,95 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiskCache = void 0;
-const file_entry_cache_1 = require("file-entry-cache");
+const fileEntryCache = __importStar(require("file-entry-cache"));
+const path_1 = require("path");
 const fileHelper_1 = require("../../fileHelper");
-const getConfigHash_1 = require("./getConfigHash");
 /**
  * Caches cspell results on disk
  */
 class DiskCache {
     constructor(cacheFileLocation, useCheckSum) {
-        this.fileEntryCache = (0, file_entry_cache_1.create)(cacheFileLocation, undefined, useCheckSum);
+        this.changedDependencies = new Set();
+        this.knownDependencies = new Set();
+        this.fileEntryCache = fileEntryCache.createFromFile((0, path_1.resolve)(cacheFileLocation), useCheckSum);
     }
-    async getCachedLintResults(filename, configInfo) {
+    async getCachedLintResults(filename) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
         const meta = fileDescriptor.meta;
+        const data = meta === null || meta === void 0 ? void 0 : meta.data;
+        const result = data === null || data === void 0 ? void 0 : data.r;
         // Cached lint results are valid if and only if:
         // 1. The file is present in the filesystem
         // 2. The file has not changed since the time it was previously linted
         // 3. The CSpell configuration has not changed since the time the file was previously linted
         // If any of these are not true, we will not reuse the lint results.
-        if (fileDescriptor.notFound ||
-            fileDescriptor.changed ||
-            !meta ||
-            meta.configHash !== (0, getConfigHash_1.getConfigHash)(configInfo)) {
+        if (fileDescriptor.notFound || fileDescriptor.changed || !meta || !result || !this.checkDependencies(data.d)) {
             return undefined;
         }
         // Skip reading empty files and files without lint error
-        const hasErrors = meta.result.errors > 0 || meta.result.configErrors > 0 || meta.result.issues.length > 0;
-        const cached = !!meta.size;
+        const hasErrors = !!result && (result.errors > 0 || result.configErrors > 0 || result.issues.length > 0);
+        const cached = true;
         const shouldReadFile = cached && hasErrors;
         return {
-            ...meta.result,
+            ...result,
             elapsedTimeMs: undefined,
             fileInfo: shouldReadFile ? await (0, fileHelper_1.readFileInfo)(filename) : { filename },
             cached,
         };
     }
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, configInfo) {
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, dependsUponFiles) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
         const meta = fileDescriptor.meta;
         if (fileDescriptor.notFound || !meta) {
             return;
         }
-        meta.result = result;
-        meta.configHash = (0, getConfigHash_1.getConfigHash)(configInfo);
+        const data = {
+            r: result,
+            d: dependsUponFiles,
+        };
+        meta.data = data;
+        this.cacheDependencies(dependsUponFiles);
     }
     reconcile() {
         this.fileEntryCache.reconcile();
     }
+    cacheDependencies(files) {
+        this.fileEntryCache.analyzeFiles(files);
+    }
+    checkDependencies(files) {
+        for (const file of files) {
+            if (this.changedDependencies.has(file)) {
+                return false;
+            }
+        }
+        const unknown = files.filter((f) => !this.knownDependencies.has(f));
+        if (!unknown.length) {
+            return true;
+        }
+        const { changedFiles, notFoundFiles } = this.fileEntryCache.analyzeFiles(files);
+        changedFiles.map((f) => this.changedDependencies.add(f));
+        unknown.forEach((f) => this.knownDependencies.add(f));
+        return changedFiles.length === 0 && notFoundFiles.length === 0;
+    }
 }
 exports.DiskCache = DiskCache;
 //# sourceMappingURL=DiskCache.js.map

package/dist/util/cache/createCache.d.ts

@@ -1,11 +1,11 @@
-import { CacheOptions } from './CacheOptions';
+import { CacheSettings, CSpellSettings } from '@cspell/cspell-types';
+import { CacheOptions } from '.';
 import { CSpellLintResultCache } from './CSpellLintResultCache';
 export declare const DEFAULT_CACHE_LOCATION = ".cspellcache";
-export interface CreateCacheOptions extends CacheOptions {
-    root: string;
-}
+export declare type CreateCacheSettings = Required<CacheSettings>;
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
-export declare function createCache(options: CreateCacheOptions): CSpellLintResultCache;
+export declare function createCache(options: CreateCacheSettings): CSpellLintResultCache;
+export declare function calcCacheSettings(config: CSpellSettings, cacheOptions: CacheOptions, root: string): Promise<CreateCacheSettings>;
 //# sourceMappingURL=createCache.d.ts.map

package/dist/util/cache/createCache.js

@@ -3,18 +3,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
+exports.calcCacheSettings = exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
 const path_1 = __importDefault(require("path"));
 const DiskCache_1 = require("./DiskCache");
 const DummyCache_1 = require("./DummyCache");
+const fs_extra_1 = require("fs-extra");
+const errors_1 = require("../errors");
 // cspell:word cspellcache
 exports.DEFAULT_CACHE_LOCATION = '.cspellcache';
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
 function createCache(options) {
-    const { cache, cacheLocation = exports.DEFAULT_CACHE_LOCATION, cacheStrategy = 'metadata', root } = options;
-    return cache ? new DiskCache_1.DiskCache(path_1.default.resolve(root, cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
+    const { useCache, cacheLocation, cacheStrategy } = options;
+    return useCache ? new DiskCache_1.DiskCache(path_1.default.resolve(cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
 }
 exports.createCache = createCache;
+async function calcCacheSettings(config, cacheOptions, root) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const cs = (_a = config.cache) !== null && _a !== void 0 ? _a : {};
+    const useCache = (_c = (_b = cacheOptions.cache) !== null && _b !== void 0 ? _b : cs.useCache) !== null && _c !== void 0 ? _c : false;
+    const cacheLocation = await resolveCacheLocation(path_1.default.resolve(root, (_e = (_d = cacheOptions.cacheLocation) !== null && _d !== void 0 ? _d : cs.cacheLocation) !== null && _e !== void 0 ? _e : exports.DEFAULT_CACHE_LOCATION));
+    const cacheStrategy = (_g = (_f = cacheOptions.cacheStrategy) !== null && _f !== void 0 ? _f : cs.cacheStrategy) !== null && _g !== void 0 ? _g : 'metadata';
+    return {
+        useCache,
+        cacheLocation,
+        cacheStrategy,
+    };
+}
+exports.calcCacheSettings = calcCacheSettings;
+async function resolveCacheLocation(cacheLocation) {
+    try {
+        const s = await (0, fs_extra_1.stat)(cacheLocation);
+        if (s.isFile())
+            return cacheLocation;
+        return path_1.default.join(cacheLocation, exports.DEFAULT_CACHE_LOCATION);
+    }
+    catch (err) {
+        if ((0, errors_1.isError)(err) && err.code === 'ENOENT') {
+            return cacheLocation;
+        }
+        throw err;
+    }
+}
 //# sourceMappingURL=createCache.js.map

package/dist/util/cache/index.d.ts

@@ -1,5 +1,4 @@
-export { createCache, DEFAULT_CACHE_LOCATION } from './createCache';
-export type { CreateCacheOptions } from './createCache';
+export { createCache, calcCacheSettings, DEFAULT_CACHE_LOCATION, type CreateCacheSettings } from './createCache';
 export type { CSpellLintResultCache } from './CSpellLintResultCache';
 export type { CacheOptions } from './CacheOptions';
 //# sourceMappingURL=index.d.ts.map

package/dist/util/cache/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_LOCATION = exports.createCache = void 0;
+exports.DEFAULT_CACHE_LOCATION = exports.calcCacheSettings = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
+Object.defineProperty(exports, "calcCacheSettings", { enumerable: true, get: function () { return createCache_1.calcCacheSettings; } });
 Object.defineProperty(exports, "DEFAULT_CACHE_LOCATION", { enumerable: true, get: function () { return createCache_1.DEFAULT_CACHE_LOCATION; } });
 //# sourceMappingURL=index.js.map

package/dist/util/errors.d.ts

@@ -4,8 +4,14 @@ export declare class CheckFailed extends Error {
 }
 export declare class ApplicationError extends Error {
     readonly exitCode: number;
-    constructor(message: string, exitCode?: number);
+    readonly cause?: Error | undefined;
+    constructor(message: string, exitCode?: number, cause?: Error | undefined);
 }
 export declare function toError(e: unknown): Error;
-export declare function isError(e: unknown): e is Error;
+export declare function isError(e: unknown): e is NodeError;
+export declare function toApplicationError(e: unknown, message?: string): ApplicationError;
+interface NodeError extends Error {
+    code?: string;
+}
+export {};
 //# sourceMappingURL=errors.d.ts.map

package/dist/util/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isError = exports.toError = exports.ApplicationError = exports.CheckFailed = void 0;
+exports.toApplicationError = exports.isError = exports.toError = exports.ApplicationError = exports.CheckFailed = void 0;
 const util_1 = require("util");
 class CheckFailed extends Error {
     constructor(message, exitCode = 1) {
@@ -10,9 +10,10 @@ class CheckFailed extends Error {
 }
 exports.CheckFailed = CheckFailed;
 class ApplicationError extends Error {
-    constructor(message, exitCode = 1) {
+    constructor(message, exitCode = 1, cause) {
         super(message);
         this.exitCode = exitCode;
+        this.cause = cause;
     }
 }
 exports.ApplicationError = ApplicationError;
@@ -31,7 +32,14 @@ function isError(e) {
     if (!e || typeof e !== 'object')
         return false;
     const ex = e;
-    return typeof ex.name === 'string' && typeof ex.message === 'string';
+    return typeof ex.message === 'string';
 }
 exports.isError = isError;
+function toApplicationError(e, message) {
+    if (e instanceof ApplicationError && !message)
+        return e;
+    const err = toError(e);
+    return new ApplicationError(message !== null && message !== void 0 ? message : err.message, undefined, err);
+}
+exports.toApplicationError = toApplicationError;
 //# sourceMappingURL=errors.js.map

package/dist/util/glob.d.ts

@@ -25,7 +25,7 @@ export declare function calcExcludeGlobInfo(root: string, commandLineExclude: st
 export declare function extractGlobExcludesFromConfig(root: string, source: string, config: CSpellUserSettings): GlobSrcInfo[];
 /**
  * Build GlobMatcher from command line or config file globs.
- * @param globs Glob patterns.
+ * @param globs Glob patterns or file paths
  * @param root - directory to use as the root
  */
 export declare function buildGlobMatcher(globs: Glob[], root: string, isExclude: boolean): GlobMatcher;

package/dist/util/glob.js

@@ -120,7 +120,7 @@ function extractGlobExcludesFromConfig(root, source, config) {
 exports.extractGlobExcludesFromConfig = extractGlobExcludesFromConfig;
 /**
  * Build GlobMatcher from command line or config file globs.
- * @param globs Glob patterns.
+ * @param globs Glob patterns or file paths
  * @param root - directory to use as the root
  */
 function buildGlobMatcher(globs, root, isExclude) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.13.3",
+  "version": "5.15.0",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -72,34 +72,36 @@
     "chalk": "^4.1.2",
     "commander": "^8.3.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.13.3",
-    "cspell-glob": "^5.13.3",
-    "cspell-lib": "^5.13.3",
+    "cspell-gitignore": "^5.15.0",
+    "cspell-glob": "^5.15.0",
+    "cspell-lib": "^5.15.0",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
     "get-stdin": "^8.0.0",
     "glob": "^7.2.0",
     "imurmurhash": "^0.1.4",
+    "semver": "^7.3.5",
     "strip-ansi": "^6.0.1",
-    "vscode-uri": "^3.0.2"
+    "vscode-uri": "^3.0.3"
   },
   "engines": {
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.13.3",
-    "@cspell/cspell-types": "^5.13.3",
+    "@cspell/cspell-json-reporter": "^5.15.0",
+    "@cspell/cspell-types": "^5.15.0",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
     "@types/imurmurhash": "^0.1.1",
     "@types/micromatch": "^4.0.2",
     "@types/minimatch": "^3.0.5",
-    "jest": "^27.4.0",
+    "@types/semver": "^7.3.9",
+    "jest": "^27.4.6",
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "f49cb2d98eed1f7274b1e6ad1ef076e7140347b5"
+  "gitHead": "04d61378054cbecd28df100ca704c7322abab8ba"
 }