@pgsql/lint 18.1.1 → 18.2.0

package/config.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Config-file support — so a repository states its lint policy once, in a file,
+ * instead of repeating flags in every workflow step and every shell history.
+ *
+ * The keys mirror the CLI flags exactly (`rules`, `warn`, `off`, `ignore`,
+ * `keyword`, `paths`), and a flag always overrides the file. Discovery walks up
+ * from `cwd` looking for `.pgsqllintrc.json` / `.pgsqllintrc`.
+ *
+ * `extends` names another config *file* (a relative path resolved against the
+ * file that declared it, or a resolvable npm module). This package has no
+ * built-in presets — its rule set is injected as values, not discovered by name
+ * — so unlike safegres's `extends: "safegres:constructive"` there is nothing to
+ * name but a file.
+ */
+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.CONFIG_FILENAMES = void 0;
+exports.findConfigFile = findConfigFile;
+exports.loadLintConfig = loadLintConfig;
+exports.configDir = configDir;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+exports.CONFIG_FILENAMES = ['.pgsqllintrc.json', '.pgsqllintrc'];
+const KNOWN_KEYS = new Set([
+    '$schema',
+    'extends',
+    'rules',
+    'warn',
+    'off',
+    'ignore',
+    'keyword',
+    'paths'
+]);
+/** Walk up from `cwd` for the first config file. */
+function findConfigFile(cwd = process.cwd()) {
+    let dir = path.resolve(cwd);
+    for (;;) {
+        for (const name of exports.CONFIG_FILENAMES) {
+            const candidate = path.join(dir, name);
+            if ((0, fs_1.existsSync)(candidate))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function readConfigFile(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse((0, fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch (err) {
+        throw new Error(`could not parse ${file}: ${err.message}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${file}: expected a JSON object`);
+    }
+    const config = parsed;
+    const unknown = Object.keys(config).filter((k) => !KNOWN_KEYS.has(k));
+    if (unknown.length > 0) {
+        throw new Error(`${file}: unknown key(s) ${unknown.join(', ')} — expected any of ` +
+            `${[...KNOWN_KEYS].filter((k) => k !== '$schema').join(', ')}`);
+    }
+    return config;
+}
+/** Resolve an `extends` target: a path relative to `from`, or an npm module. */
+function resolveExtends(target, from) {
+    const asPath = path.resolve(path.dirname(from), target);
+    for (const candidate of [asPath, `${asPath}.json`]) {
+        if ((0, fs_1.existsSync)(candidate))
+            return candidate;
+    }
+    try {
+        return require.resolve(target, { paths: [path.dirname(from)] });
+    }
+    catch {
+        throw new Error(`${from}: could not resolve "extends": ${target} — it is read as a path ` +
+            'relative to the file that declared it, or as an npm module');
+    }
+}
+/** Later layers win; array keys replace rather than merge. */
+function merge(base, over) {
+    const out = { ...base, ...over };
+    delete out.extends;
+    return out;
+}
+function expand(file, seen) {
+    if (seen.has(file))
+        throw new Error(`circular "extends" chain at ${file}`);
+    seen.add(file);
+    const config = readConfigFile(file);
+    const parents = config.extends
+        ? Array.isArray(config.extends)
+            ? config.extends
+            : [config.extends]
+        : [];
+    let acc = {};
+    for (const parent of parents) {
+        acc = merge(acc, expand(resolveExtends(parent, file), seen));
+    }
+    return merge(acc, config);
+}
+/**
+ * Load the effective config: an explicit `configFile`, else the nearest
+ * discovered one, else empty. Paths in `ignore`/`paths` stay as written — the
+ * caller resolves them against the config file's directory (see `configDir`).
+ */
+function loadLintConfig(params = {}) {
+    const cwd = params.cwd ?? process.cwd();
+    const filepath = params.configFile
+        ? path.resolve(cwd, params.configFile)
+        : findConfigFile(cwd);
+    if (!filepath)
+        return { config: {} };
+    if (!(0, fs_1.existsSync)(filepath))
+        throw new Error(`config file not found: ${filepath}`);
+    return { config: expand(filepath, new Set()), filepath };
+}
+/** The directory a discovered config's relative paths resolve against. */
+function configDir(loaded, cwd = process.cwd()) {
+    return loaded.filepath ? path.dirname(loaded.filepath) : cwd;
+}

package/esm/changed.js

@@ -0,0 +1,121 @@
+/**
+ * Changed-file detection for `--changed`, so a CI gate (or a human before a
+ * commit) pays only for the SQL that a branch actually touched.
+ *
+ * Modelled on pgpm's bundle-drift check (`pgpm/core/src/packaging/check.ts` in
+ * constructive): resolve a base ref (explicit → `origin/$GITHUB_BASE_REF` in a
+ * PR → the repository's default branch), diff `HEAD` against the **merge base**
+ * so unrelated commits on the base branch don't widen the set, and union that
+ * with uncommitted/untracked working-tree changes. Deleted paths are dropped —
+ * there is nothing left on disk to lint.
+ */
+import { execFileSync } from 'child_process';
+import { existsSync, statSync } from 'fs';
+import * as path from 'path';
+function git(args, cwd) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: 64 * 1024 * 1024
+    });
+}
+function tryGit(args, cwd) {
+    try {
+        return git(args, cwd);
+    }
+    catch {
+        return null;
+    }
+}
+/** The repository's default branch as a remote-tracking ref, when discoverable. */
+function defaultBranch(cwd) {
+    const head = tryGit(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], cwd);
+    if (head && head.trim())
+        return head.trim();
+    for (const candidate of ['origin/main', 'origin/master', 'main', 'master']) {
+        if (tryGit(['rev-parse', '--verify', '--quiet', candidate], cwd))
+            return candidate;
+    }
+    return undefined;
+}
+/**
+ * Resolve the ref to diff against. An explicit `base` wins; otherwise the PR
+ * base branch (`origin/$GITHUB_BASE_REF`) when running in GitHub Actions;
+ * otherwise the repository's default branch. `undefined` means "no base" and
+ * the caller falls back to working-tree changes only.
+ */
+export function resolveChangedBase(base, cwd = process.cwd()) {
+    if (base && base.trim())
+        return base.trim();
+    const prBase = process.env.GITHUB_BASE_REF;
+    if (prBase && prBase.trim()) {
+        const ref = `origin/${prBase.trim()}`;
+        if (tryGit(['rev-parse', '--verify', '--quiet', ref], cwd))
+            return ref;
+        return prBase.trim();
+    }
+    return defaultBranch(cwd);
+}
+/** Parse `git status --porcelain` into paths (rename target wins). */
+function workingTreePaths(cwd) {
+    const out = [];
+    // `-uall` lists untracked *files*; the default collapses a new directory to
+    // the directory name, which would hide every file a new module adds.
+    const status = tryGit(['status', '--porcelain', '-uall'], cwd) ?? '';
+    for (const rawLine of status.split('\n')) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        let p = line.slice(3);
+        const arrow = p.indexOf(' -> ');
+        if (arrow !== -1)
+            p = p.slice(arrow + 4);
+        p = p.replace(/^"|"$/g, '');
+        if (p)
+            out.push(p);
+    }
+    return out;
+}
+/**
+ * Collect the files that differ from `base` (via `git merge-base`) plus any
+ * uncommitted/untracked working-tree changes. Falls back to `git diff HEAD`
+ * when no base is resolvable or no merge base exists — a shallow clone or a
+ * detached CI checkout — rather than failing the run.
+ */
+export function changedFiles(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (!tryGit(['rev-parse', '--git-dir'], cwd)) {
+        throw new Error(`--changed needs a git repository; ${cwd} is not inside one`);
+    }
+    const files = new Set(workingTreePaths(cwd));
+    const base = resolveChangedBase(options.base, cwd);
+    let mergeBase;
+    if (base) {
+        const found = tryGit(['merge-base', 'HEAD', base], cwd);
+        mergeBase = found?.trim() || undefined;
+    }
+    // No base, or no common ancestor (shallow clone / detached checkout): the
+    // uncommitted diff against HEAD is all the history we can see.
+    const diffArgs = mergeBase
+        ? ['diff', '--name-only', '--diff-filter=ACMR', mergeBase, 'HEAD']
+        : ['diff', '--name-only', '--diff-filter=ACMR', 'HEAD'];
+    for (const rawLine of (tryGit(diffArgs, cwd) ?? '').split('\n')) {
+        const p = rawLine.trim();
+        if (p)
+            files.add(p);
+    }
+    const abs = [];
+    for (const rel of files) {
+        const full = path.resolve(cwd, rel);
+        // Deleted or renamed-away paths have nothing left to lint.
+        if (existsSync(full) && statSync(full).isFile())
+            abs.push(full);
+    }
+    return { files: abs.sort(), base, mergeBase };
+}
+/** {@link changedFiles}, narrowed to `.sql`. */
+export function changedSqlFiles(options = {}) {
+    const result = changedFiles(options);
+    return { ...result, files: result.files.filter((f) => f.toLowerCase().endsWith('.sql')) };
+}

package/esm/cli.js

@@ -2,15 +2,21 @@
 /**
  * `pgsql-lint` — lint SQL source files for the convention rules.
  *
- *   pgsql-lint <path…> [--rules a,b] [--warn a,b] [--off a,b] [--json] [--quiet]
+ *   pgsql-lint <path…> [--changed[=<base>]] [--ignore <globs>] [--rules a,b]
+ *              [--warn a,b] [--off a,b] [--config <file>] [--json] [--quiet]
  *
  * Paths may be files or directories (directories are scanned recursively for
- * `.sql`). Exit code is 1 when any *error*-severity finding remains, 0
- * otherwise — so it drops straight into a pre-commit hook or CI step. Findings
- * downgraded with `--warn` print but never fail the run.
+ * `.sql`), and default to `paths` from the config file. Exit code is 1 when any
+ * *error*-severity finding remains, 0 otherwise — so it drops straight into a
+ * pre-commit hook or CI step. Findings downgraded with `--warn` print but never
+ * fail the run.
  */
 import chalk from 'chalk';
+import { existsSync } from 'fs';
 import minimist from 'minimist';
+import * as path from 'path';
+import { changedSqlFiles } from './changed';
+import { configDir, loadLintConfig } from './config';
 import { lintFiles } from './file-runner';
 import { LINT_RULES } from './rules';
 const HELP = `pgsql-lint — source-level SQL/PL/pgSQL convention linter
@@ -20,17 +26,29 @@ Usage:
 
 Arguments:
   path                 One or more .sql files or directories (scanned recursively).
+                       Defaults to "paths" from the config file.
 
 Options:
+  --changed[=<base>]   Lint only .sql files that differ from <base> (default: the
+                       PR base branch, else the repository default branch), using
+                       the merge base, plus working-tree changes. Exits 0 when
+                       nothing changed.
+  --ignore <globs>     Exclude paths (comma-separated, repeatable).
   --rules <ids>        Comma-separated rule ids/codes to run (default: all).
   --warn <ids>         Report these rules as warnings (do not fail the run).
   --off <ids>          Disable these rules entirely.
   --keyword <kw>       Suppression directive keyword (default: pgsql-lint,safegres).
+  --config <file>      Config file to use (default: nearest .pgsqllintrc.json).
+  --no-config          Ignore any config file.
   --json               Emit findings as JSON.
   --quiet              Only print active findings (hide acknowledged waivers).
   -h, --help           Show this help.
   -v, --version        Show version.
 
+Config file (.pgsqllintrc.json, discovered upward from cwd; flags override it):
+  { "extends": "./base.json", "rules": [], "warn": [], "off": [],
+    "ignore": ["sql/", "**/generated/**"], "keyword": [], "paths": ["packages"] }
+
 Rules:
 ${LINT_RULES.map((r) => `  ${r.code}  ${r.id}  —  ${r.title}`).join('\n')}
 
@@ -38,33 +56,114 @@ Suppress inline (in the function body):
   -- pgsql-lint-disable-next-line no-dynamic-sql -- lookup-only: <why>
 `;
 function csv(v) {
-    if (!v)
+    if (v === undefined)
         return undefined;
-    const parts = v.split(',').map((s) => s.trim()).filter(Boolean);
+    const parts = (Array.isArray(v) ? v : [v])
+        .flatMap((s) => s.split(','))
+        .map((s) => s.trim())
+        .filter(Boolean);
     return parts.length > 0 ? parts : undefined;
 }
+/**
+ * Own version. In the repo the compiled CLI sits in `dist/`, but the published
+ * package flattens `dist/` to its root, so `../package.json` only resolves in
+ * one of the two layouts — try both rather than crashing on `--version`.
+ */
+function packageVersion() {
+    for (const candidate of ['../package.json', './package.json']) {
+        try {
+            return require(candidate).version;
+        }
+        catch {
+            // Wrong layout; try the next candidate.
+        }
+    }
+    return 'unknown';
+}
+/**
+ * `--changed` takes an *optional* value, which minimist cannot express: with
+ * `string: ['changed']` it would swallow a following path. Bind the next token
+ * only when it is not a flag and not an existing path — i.e. when it reads as a
+ * git ref — and otherwise rewrite the flag to an empty value.
+ */
+function normalizeChanged(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] !== '--changed') {
+            out.push(args[i]);
+            continue;
+        }
+        const next = args[i + 1];
+        if (next && !next.startsWith('-') && !existsSync(next)) {
+            out.push(`--changed=${next}`);
+            i++;
+        }
+        else {
+            out.push('--changed=');
+        }
+    }
+    return out;
+}
 async function main() {
-    const argv = minimist(process.argv.slice(2), {
+    const raw = process.argv.slice(2);
+    // Handled here rather than as a minimist boolean: `config` also takes a value.
+    const noConfig = raw.includes('--no-config');
+    const argv = minimist(normalizeChanged(raw.filter((a) => a !== '--no-config')), {
         boolean: ['json', 'quiet', 'help', 'version'],
-        string: ['rules', 'warn', 'off', 'keyword'],
+        string: ['rules', 'warn', 'off', 'keyword', 'changed', 'ignore', 'config'],
         alias: { h: 'help', v: 'version' }
     });
     if (argv.version) {
-        console.log(require('../package.json').version);
+        console.log(packageVersion());
         return;
     }
-    if (argv.help || argv._.length === 0) {
+    const cwd = process.cwd();
+    const loaded = noConfig
+        ? { config: {} }
+        : loadLintConfig({ cwd, configFile: argv.config || undefined });
+    const fileConfig = loaded.config;
+    const baseDir = configDir(loaded, cwd);
+    const useChanged = argv.changed !== undefined;
+    const paths = argv._.length > 0
+        ? argv._
+        : (fileConfig.paths ?? []).map((p) => path.resolve(baseDir, p));
+    if (argv.help || (!useChanged && paths.length === 0)) {
         console.log(HELP);
-        process.exit(argv._.length === 0 && !argv.help ? 1 : 0);
+        process.exit(argv.help ? 0 : 1);
     }
-    const rules = csv(argv.rules);
-    const keyword = csv(argv.keyword);
+    const rules = csv(argv.rules) ?? fileConfig.rules;
+    const keyword = csv(argv.keyword) ?? (fileConfig.keyword ? csv(fileConfig.keyword) : undefined);
+    const ignore = csv(argv.ignore) ?? fileConfig.ignore;
     const severity = {};
-    for (const id of csv(argv.warn) ?? [])
+    for (const id of csv(argv.warn) ?? fileConfig.warn ?? [])
         severity[id] = 'warn';
-    for (const id of csv(argv.off) ?? [])
+    for (const id of csv(argv.off) ?? fileConfig.off ?? [])
         severity[id] = 'off';
-    const reports = await lintFiles(argv._, { rules, keyword, severity });
+    let targets;
+    if (useChanged) {
+        const changed = changedSqlFiles({ cwd, base: argv.changed || undefined });
+        // Nothing to lint is a pass, not an error — the common case on a branch
+        // that touched no SQL at all.
+        if (changed.files.length === 0) {
+            if (argv.json)
+                console.log('[]');
+            else
+                console.log(chalk.green('0 errors'), chalk.gray('(no changed .sql files)'));
+            process.exit(0);
+        }
+        targets = paths.length > 0 ? withinPaths(changed.files, paths) : changed.files;
+        if (targets.length === 0) {
+            if (argv.json)
+                console.log('[]');
+            else
+                console.log(chalk.green('0 errors'), chalk.gray('(no changed .sql files under the given paths)'));
+            process.exit(0);
+        }
+    }
+    else {
+        targets = paths;
+    }
+    const reports = await lintFiles(targets, { rules, keyword, severity, ignore, cwd: baseDir });
     if (argv.json) {
         console.log(JSON.stringify(reports, null, 2));
     }
@@ -104,6 +203,16 @@ async function main() {
     }
     process.exit(errors > 0 ? 1 : 0);
 }
+/** Keep only changed files that sit inside one of the requested paths. */
+function withinPaths(files, paths) {
+    const roots = paths.map((p) => path.resolve(p));
+    return files.filter((file) => roots.some((root) => {
+        if (file === root)
+            return true;
+        const rel = path.relative(root, file);
+        return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+    }));
+}
 function formatFinding(f) {
     const loc = chalk.gray(`${String(f.line).padStart(4)}`);
     const tag = f.acknowledged

package/esm/config.js

@@ -0,0 +1,118 @@
+/**
+ * Config-file support — so a repository states its lint policy once, in a file,
+ * instead of repeating flags in every workflow step and every shell history.
+ *
+ * The keys mirror the CLI flags exactly (`rules`, `warn`, `off`, `ignore`,
+ * `keyword`, `paths`), and a flag always overrides the file. Discovery walks up
+ * from `cwd` looking for `.pgsqllintrc.json` / `.pgsqllintrc`.
+ *
+ * `extends` names another config *file* (a relative path resolved against the
+ * file that declared it, or a resolvable npm module). This package has no
+ * built-in presets — its rule set is injected as values, not discovered by name
+ * — so unlike safegres's `extends: "safegres:constructive"` there is nothing to
+ * name but a file.
+ */
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+export const CONFIG_FILENAMES = ['.pgsqllintrc.json', '.pgsqllintrc'];
+const KNOWN_KEYS = new Set([
+    '$schema',
+    'extends',
+    'rules',
+    'warn',
+    'off',
+    'ignore',
+    'keyword',
+    'paths'
+]);
+/** Walk up from `cwd` for the first config file. */
+export function findConfigFile(cwd = process.cwd()) {
+    let dir = path.resolve(cwd);
+    for (;;) {
+        for (const name of CONFIG_FILENAMES) {
+            const candidate = path.join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function readConfigFile(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new Error(`could not parse ${file}: ${err.message}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${file}: expected a JSON object`);
+    }
+    const config = parsed;
+    const unknown = Object.keys(config).filter((k) => !KNOWN_KEYS.has(k));
+    if (unknown.length > 0) {
+        throw new Error(`${file}: unknown key(s) ${unknown.join(', ')} — expected any of ` +
+            `${[...KNOWN_KEYS].filter((k) => k !== '$schema').join(', ')}`);
+    }
+    return config;
+}
+/** Resolve an `extends` target: a path relative to `from`, or an npm module. */
+function resolveExtends(target, from) {
+    const asPath = path.resolve(path.dirname(from), target);
+    for (const candidate of [asPath, `${asPath}.json`]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    try {
+        return require.resolve(target, { paths: [path.dirname(from)] });
+    }
+    catch {
+        throw new Error(`${from}: could not resolve "extends": ${target} — it is read as a path ` +
+            'relative to the file that declared it, or as an npm module');
+    }
+}
+/** Later layers win; array keys replace rather than merge. */
+function merge(base, over) {
+    const out = { ...base, ...over };
+    delete out.extends;
+    return out;
+}
+function expand(file, seen) {
+    if (seen.has(file))
+        throw new Error(`circular "extends" chain at ${file}`);
+    seen.add(file);
+    const config = readConfigFile(file);
+    const parents = config.extends
+        ? Array.isArray(config.extends)
+            ? config.extends
+            : [config.extends]
+        : [];
+    let acc = {};
+    for (const parent of parents) {
+        acc = merge(acc, expand(resolveExtends(parent, file), seen));
+    }
+    return merge(acc, config);
+}
+/**
+ * Load the effective config: an explicit `configFile`, else the nearest
+ * discovered one, else empty. Paths in `ignore`/`paths` stay as written — the
+ * caller resolves them against the config file's directory (see `configDir`).
+ */
+export function loadLintConfig(params = {}) {
+    const cwd = params.cwd ?? process.cwd();
+    const filepath = params.configFile
+        ? path.resolve(cwd, params.configFile)
+        : findConfigFile(cwd);
+    if (!filepath)
+        return { config: {} };
+    if (!existsSync(filepath))
+        throw new Error(`config file not found: ${filepath}`);
+    return { config: expand(filepath, new Set()), filepath };
+}
+/** The directory a discovered config's relative paths resolve against. */
+export function configDir(loaded, cwd = process.cwd()) {
+    return loaded.filepath ? path.dirname(loaded.filepath) : cwd;
+}

package/esm/file-runner.js

@@ -13,6 +13,7 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 import { parse } from 'pgsql-parser';
 import { lintDefinition } from './engine';
+import { applyIgnore } from './ignore';
 import { findAll } from './walk';
 /** Count newlines before `offset` — the 0-based line the offset sits on. */
 function lineAtOffset(text, offset) {
@@ -154,7 +155,7 @@ async function sqlFilesUnder(dir) {
     return out;
 }
 /** Resolve a mix of file and directory paths to a sorted list of `.sql` files. */
-export async function resolveSqlFiles(paths) {
+export async function resolveSqlFiles(paths, options = {}) {
     const files = new Set();
     for (const p of paths) {
         const st = await fs.stat(p);
@@ -166,11 +167,11 @@ export async function resolveSqlFiles(paths) {
             files.add(p);
         }
     }
-    return [...files].sort();
+    return applyIgnore([...files].sort(), options.ignore, options.cwd);
 }
 /** Lint every `.sql` file reachable from `paths` (files or directories). */
 export async function lintFiles(paths, options = {}) {
-    const files = await resolveSqlFiles(paths);
+    const files = await resolveSqlFiles(paths, { ignore: options.ignore, cwd: options.cwd });
     const reports = [];
     for (const file of files) {
         const source = await fs.readFile(file, 'utf8');
@@ -184,11 +185,11 @@ export function sqlTextAdapter(source, file) {
     return { id: 'sql-text', definitions: () => sqlTextDefinitions(source, file) };
 }
 /** A {@link SourceAdapter} over `.sql` files/directories on disk. */
-export function filesAdapter(paths) {
+export function filesAdapter(paths, options = {}) {
     return {
         id: 'files',
         definitions: async () => {
-            const files = await resolveSqlFiles(paths);
+            const files = await resolveSqlFiles(paths, options);
             const out = [];
             for (const file of files) {
                 out.push(...(await sqlTextDefinitions(await fs.readFile(file, 'utf8'), file)));