@alint-js/cli 0.0.9 → 0.0.10

package/dist/bin/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as executeCli } from "../cli-GIOYMybU.mjs";
+import { t as executeCli } from "../cli-D4YC9Jnb.mjs";
 import process from "node:process";
 //#region src/bin/index.ts
 executeCli(process.argv, {

package/dist/{cli-GIOYMybU.mjs → cli-D4YC9Jnb.mjs}

@@ -3,7 +3,7 @@ import { inspect } from "node:util";
 import { cac } from "cac";
 import { getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, writeSetupConfig } from "@alint-js/config";
 import { AlintRunError, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, resolveConfigForFile, runAlint } from "@alint-js/core";
-import { join, relative, resolve } from "pathe";
+import { isAbsolute, join, relative, resolve } from "pathe";
 import { getBorderCharacters, table } from "table";
 import { errorMessageFrom } from "@moeru/std/error";
 import { appendFile, mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
@@ -11,7 +11,7 @@ import c, { createColors } from "tinyrainbow";
 import cliSpinners from "cli-spinners";
 import { relative as relative$1 } from "node:path";
 import Gitignore from "gitignore-fs";
-import { minimatch } from "minimatch";
+import { Minimatch, minimatch } from "minimatch";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
 //#region src/cli/commands/command.ts
 function defineCommand(node) {
@@ -936,9 +936,28 @@ function createRenderingProgressReporter(summary, renderer) {
 }
 //#endregion
 //#region src/cli/commands/lint/discovery.ts
-async function resolveLintFiles(files, config, cwd) {
+const minimatchOptions = { dot: true };
+var NoFilesFoundError = class extends Error {
+	globInputPaths;
+	pattern;
+	constructor(pattern, options) {
+		super(`No files matching "${pattern}" were found${options.globInputPaths ? "" : " (glob input is disabled)"}.`);
+		this.name = "NoFilesFoundError";
+		this.globInputPaths = options.globInputPaths;
+		this.pattern = pattern;
+	}
+};
+async function findFiles(options) {
+	const { config, cwd, errorOnUnmatchedPattern = true, globInputPaths = true, inputs } = options;
 	const gitignore = shouldFilterGitignoredFiles(config) ? new Gitignore() : void 0;
-	const candidates = files.length > 0 ? files : await discoverLintFiles(config, cwd, gitignore);
+	const candidates = await resolveInputFiles({
+		config,
+		cwd,
+		errorOnUnmatchedPattern,
+		gitignore,
+		globInputPaths,
+		inputs: inputs.length > 0 ? inputs : ["."]
+	});
 	if (!gitignore || candidates.length === 0) return candidates;
 	const lintFiles = [];
 	for (const file of candidates) {
@@ -950,31 +969,122 @@ async function resolveLintFiles(files, config, cwd) {
 function collectGlobalIgnorePatterns(config) {
 	return normalizeConfig(config).flatMap((item) => isGlobalIgnoreItem(item) ? [...item.ignores] : []);
 }
-async function discoverLintFiles(config, cwd, gitignore) {
-	if (!hasDiscoveryFilePatterns(config)) return [];
-	const candidates = (await walkFiles(cwd, {
-		cwd,
-		gitignore,
-		ignoredPatterns: collectGlobalIgnorePatterns(config)
-	})).map((file) => normalizeRelativePath(cwd, file)).filter((file) => matchesDiscoveryFile(file, config, { cwd }));
-	return [...new Set(candidates)].sort();
+function getGlobParent(input) {
+	const segments = input.replaceAll("\\", "/").split("/");
+	const parentSegments = [];
+	for (const segment of segments) {
+		if (isGlobPattern(segment)) break;
+		parentSegments.push(segment);
+	}
+	const parent = parentSegments.join("/");
+	return parent === "" ? "." : parent;
 }
 function isGlobalIgnoreItem(item) {
 	const keys = Object.keys(item).filter((key) => item[key] !== void 0);
 	return item.ignores !== void 0 && keys.every((key) => key === "ignores" || key === "name");
 }
+function isGlobPattern(input) {
+	return new Minimatch(input, minimatchOptions).hasMagic();
+}
+function isNodeError$1(error) {
+	return error instanceof Error && "code" in error;
+}
+function matchesGlob(filePath, pattern) {
+	return minimatch(filePath, pattern.replaceAll("\\", "/"), minimatchOptions);
+}
 function matchesIgnoredDirectory(relativePath, patterns) {
-	return patterns.some((pattern) => minimatch(relativePath, pattern, { dot: true }) || minimatch(`${relativePath}/`, pattern, { dot: true }) || minimatch(`${relativePath}/__alint__`, pattern, { dot: true }));
+	return patterns.some((pattern) => minimatch(relativePath, pattern, minimatchOptions) || minimatch(`${relativePath}/`, pattern, minimatchOptions) || minimatch(`${relativePath}/__alint__`, pattern, minimatchOptions));
+}
+function normalizeGlobPattern(cwd, pattern) {
+	return isAbsolute(pattern) ? normalizeRelativePath(cwd, pattern) : pattern.replaceAll("\\", "/");
 }
 function normalizeRelativePath(cwd, filePath) {
 	return relative(cwd, filePath).replaceAll("\\", "/");
 }
+async function resolveInputFiles(options) {
+	const hasFilePatterns = hasDiscoveryFilePatterns(options.config);
+	const ignoredPatterns = collectGlobalIgnorePatterns(options.config);
+	const candidates = [];
+	for (const input of options.inputs) {
+		const path = resolve(options.cwd, input);
+		const stats = await statPath(path);
+		if (stats?.isFile()) {
+			candidates.push(input);
+			continue;
+		}
+		if (stats?.isDirectory()) {
+			if (!hasFilePatterns) continue;
+			if (await shouldPruneDirectory(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})) continue;
+			const directoryFiles = (await walkFiles(path, {
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				ignoredPatterns
+			})).sort();
+			for (const directoryFile of directoryFiles) {
+				const relativePath = normalizeRelativePath(options.cwd, directoryFile);
+				if (hasFilePatterns && matchesDiscoveryFile(relativePath, options.config, { cwd: options.cwd })) candidates.push(relativePath);
+			}
+			continue;
+		}
+		if (options.globInputPaths && isGlobPattern(input)) {
+			const matches = await searchGlob({
+				config: options.config,
+				cwd: options.cwd,
+				gitignore: options.gitignore,
+				hasFilePatterns,
+				ignoredPatterns,
+				pattern: input
+			});
+			if (matches.length === 0 && options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+			candidates.push(...matches);
+			continue;
+		}
+		if (options.errorOnUnmatchedPattern) throw new NoFilesFoundError(input, { globInputPaths: options.globInputPaths });
+	}
+	return [...new Set(candidates)];
+}
+async function searchGlob(options) {
+	const root = resolve(options.cwd, getGlobParent(options.pattern));
+	const rootStats = await statPath(root);
+	const pattern = normalizeGlobPattern(options.cwd, options.pattern);
+	if (!rootStats?.isDirectory()) return [];
+	const files = (await walkFiles(root, {
+		cwd: options.cwd,
+		gitignore: options.gitignore,
+		ignoredPatterns: options.ignoredPatterns
+	})).sort();
+	const candidates = [];
+	for (const file of files) {
+		const relativePath = normalizeRelativePath(options.cwd, file);
+		if (matchesGlob(relativePath, pattern) && shouldIncludeGlobCandidate(relativePath, options.config, {
+			cwd: options.cwd,
+			hasFilePatterns: options.hasFilePatterns
+		})) candidates.push(relativePath);
+	}
+	return candidates;
+}
 function shouldFilterGitignoredFiles(config) {
 	return normalizeConfig(config).some((item) => item.ignore?.gitignore === true);
 }
+function shouldIncludeGlobCandidate(filePath, config, options) {
+	if (options.hasFilePatterns) return matchesDiscoveryFile(filePath, config, { cwd: options.cwd });
+	return !resolveConfigForFile(filePath, config, { cwd: options.cwd }).ignored;
+}
 async function shouldPruneDirectory(path, options) {
 	if (matchesIgnoredDirectory(normalizeRelativePath(options.cwd, path), options.ignoredPatterns)) return true;
-	return await options.gitignore?.ignores(path) === true;
+	return await options.gitignore?.ignores(`${path}/`) === true;
+}
+async function statPath(path) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isNodeError$1(error) && (error.code === "ENOENT" || error.code === "ENOTDIR")) return;
+		throw error;
+	}
 }
 async function walkFiles(root, options) {
 	const entries = await readdir(root, { withFileTypes: true });
@@ -1388,7 +1498,22 @@ function isNodeError(error) {
 async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	if (options.config) await assertConfigExists(io.cwd, options.config);
 	const [setupConfig, config] = await Promise.all([loadMergedSetupConfig(io), loadAlintConfig(io.cwd, options.config)]);
-	const lintFiles = await resolveLintFiles(files, config, io.cwd);
+	let lintFiles;
+	try {
+		lintFiles = await findFiles({
+			config,
+			cwd: io.cwd,
+			errorOnUnmatchedPattern: true,
+			globInputPaths: true,
+			inputs: files
+		});
+	} catch (error) {
+		if (error instanceof NoFilesFoundError) {
+			io.stderr.write(`${error.message}\n`);
+			return 2;
+		}
+		throw error;
+	}
 	const runner = resolveRunnerConfig(setupConfig, { runner: resolveConfigRunner(config) }, options);
 	const progress = shouldEnableProgress(options, io) ? createCliProgressReporter({
 		color: io.stderr.isTTY === true,

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-GIOYMybU.mjs";
+import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-D4YC9Jnb.mjs";
 export { executeCli, formatDiagnostics, formatJson, formatStylish };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -25,8 +25,8 @@
     "pathe": "^2.0.3",
     "table": "^6.9.0",
     "tinyrainbow": "^3.1.0",
-    "@alint-js/config": "0.0.9",
-    "@alint-js/core": "0.0.9"
+    "@alint-js/core": "0.0.10",
+    "@alint-js/config": "0.0.10"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",