@alint-js/cli 0.4.0 → 0.5.0

package/README.md

@@ -207,6 +207,43 @@ alint --format json src > alint-output.json
 alint output inspect alint-output.json
 ```
 
+### Editor Integration
+
+> **Work in progress.** `alint lsp` currently publishes cached diagnostics when an editor opens a
+> workspace, and nothing more. Saving a file does not refresh it, changing `alint.config.ts` does
+> not reload it, and the run commands below are advertised but not yet implemented. Restart the
+> server to pick up either kind of change.
+
+`alint lsp` runs alint as a language server over stdin and stdout.
+
+It is cache-first. The server reads diagnostics that earlier runs already stored and **never calls
+a model on its own**, so opening a workspace costs nothing. A cold cache therefore shows nothing —
+run `alint` once to populate it.
+
+Point any LSP editor at the command. In Neovim:
+
+```lua
+vim.lsp.config.alint = {
+  cmd = { 'alint', 'lsp' },
+  root_markers = { 'alint.config.ts' },
+}
+```
+
+The server declares two commands, `alint.runFile` and `alint.runWorkspace`, which will start runs
+that call models and spend tokens. Both return `MethodNotFound` today.
+
+A VS Code extension lives in `apps/vscode`. It starts the server and shows the diagnostics; it is
+not published to the marketplace yet. To run it from a checkout:
+
+```bash
+pnpm -F @alint-js/vscode build
+code --extensionDevelopmentPath=apps/vscode /path/to/your/project
+```
+
+It resolves the alint executable from the `alint.path` setting, then `node_modules/.bin/alint` in
+the workspace folder, then `PATH`. The workspace install wins so that the server and the alint you
+run in a terminal share one cache.
+
 ## Concepts
 
 `alint` keeps the familiar lint shape: select targets, apply named rules, report diagnostics, and return an exit code that CI can understand. The difference is that a rule can reach its judgment through model calls or a tool-using agent when syntax-only checks are not enough.

package/dist/bin/index.mjs

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

package/dist/{cli-DFWnPI6m.mjs → cli-ChymU1Wr.mjs}

@@ -18,7 +18,7 @@ import Gitignore from "gitignore-fs";
 import { Minimatch, minimatch } from "minimatch";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std";
 //#region package.json
-var version = "0.4.0";
+var version = "0.5.0";
 //#endregion
 //#region src/cli/output.ts
 function escapeLineValue(value) {
@@ -47,6 +47,7 @@ function dispatchCommand(context, node, args, options, path) {
 	const [subcommand, ...restArgs] = args;
 	const child = node.children?.find((item) => item.name === subcommand || item.alias?.includes(subcommand ?? ""));
 	if (child) return dispatchCommand(context, child, restArgs, options, [...path, child.name]);
+	if (subcommand === void 0 && node.children?.length && !node.action) return Promise.resolve(reportMissingSubcommand(context, path, node.children));
 	if (!node.action) return Promise.resolve(reportUnknownCommand(context, path, args));
 	if (node.exactArguments === true) {
 		const unexpectedArgument = args[node.arguments?.split(/\s+/u).filter(Boolean).length ?? 0];
@@ -170,6 +171,19 @@ function registerRootCommand(cli, node, context, setPendingResult) {
 		return setPendingResult(node.children ? dispatchCommand(context, node, args[0] ?? [], options, [node.name]) : Promise.resolve(node.action?.(context, ...args.slice(0, -1), options) ?? 0));
 	});
 }
+function reportMissingSubcommand(context, path, children) {
+	const command = path.join(" ");
+	context.io.stderr.write([
+		`missing subcommand for "${command}"`,
+		"",
+		"available subcommands:",
+		...children.map((child) => `  ${child.name}`),
+		"",
+		`run \`alint ${command} --help\` for more information`,
+		""
+	].join("\n"));
+	return 2;
+}
 function reportUnknownCommand(context, path, args) {
 	context.io.stderr.write(`unknown command: ${formatUnknownCommand(path, args)}\n`);
 	return 2;
@@ -3088,6 +3102,96 @@ async function* walkFiles(root, options) {
 	}
 }
 //#endregion
+//#region src/cli/runtime/runner.ts
+/**
+* Merges the setup config runner with the project config runner. No CLI flag is applied.
+*
+* `runner.cache` selects the cache file. The lint command and the language server must merge it
+* the same way, or the editor reads a different file and reports nothing.
+*/
+function mergeRunnerConfigs(setupRunner, configRunner) {
+	const runner = {
+		...setupRunner ?? {},
+		...configRunner ?? {},
+		cache: mergeCacheConfig(setupRunner?.cache, configRunner?.cache),
+		ruleConcurrency: configRunner?.ruleConcurrency ?? setupRunner?.ruleConcurrency,
+		stats: mergeStatsConfig(setupRunner?.stats, configRunner?.stats),
+		timeoutMs: configRunner?.timeoutMs ?? setupRunner?.timeoutMs
+	};
+	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
+}
+/** The last `runner` block in the flattened config wins, key by key. */
+function resolveConfigRunner(config) {
+	return normalizeConfig(config).reduce((merged, item) => item.runner ? {
+		...merged,
+		...item.runner
+	} : merged, void 0);
+}
+function mergeCacheConfig(setupCache, configCache) {
+	if (configCache === void 0) return setupCache;
+	if (typeof configCache === "boolean") return configCache;
+	if (typeof setupCache === "object") return {
+		...setupCache,
+		...configCache
+	};
+	return configCache;
+}
+function mergeStatsConfig(setupStats, configStats) {
+	if (configStats === void 0) return setupStats;
+	if (typeof configStats === "boolean") return configStats;
+	if (typeof setupStats === "object") return {
+		...setupStats,
+		...configStats
+	};
+	return configStats;
+}
+//#endregion
+//#region src/cli/runtime/session.ts
+/**
+* Loads config, setup config, and model adapters once, then runs any number of times.
+*
+* The lint command and the language server both use this function. A second implementation would
+* resolve config or cwd differently, and the editor would then read a different cache file.
+*/
+async function createRunSession(io, options = {}) {
+	const [{ defaultModel, setupConfig: fileSetupConfig }, config] = await Promise.all([loadRunSetupConfig(io), loadAlintConfig(io.cwd, options.configPath)]);
+	const runtime = await (options.startModelAdapters ?? startModelAdapters)(fileSetupConfig, io);
+	const { setupConfig } = runtime;
+	let shutdown;
+	return {
+		config,
+		cwd: io.cwd,
+		defaultModel,
+		run: async (runOptions) => {
+			const targets = await findLintTargets({
+				config,
+				cwd: io.cwd,
+				errorOnUnmatchedPattern: true,
+				globInputPaths: true,
+				inputs: runOptions.files ?? []
+			});
+			return runAlint({
+				cacheOnly: runOptions.cacheOnly,
+				config,
+				cwd: io.cwd,
+				defaultModel,
+				directories: targets.directories,
+				files: targets.files,
+				modelOverride: runOptions.modelOverride,
+				outputLanguage: runOptions.outputLanguage,
+				progress: runOptions.progress,
+				projectTargets: runOptions.projectTargets,
+				runner: runOptions.runner,
+				setupConfig,
+				signal: runOptions.signal
+			});
+		},
+		runner: mergeRunnerConfigs(setupConfig.runner, resolveConfigRunner(config)),
+		setupConfig,
+		shutdown: () => shutdown ??= runtime.shutdown()
+	};
+}
+//#endregion
 //#region src/cli/commands/lint/errors.ts
 const colors$1 = createColors({ force: true });
 function formatCancelledError(error, color) {
@@ -3155,63 +3259,37 @@ function groupFailuresByRule(failures) {
 }
 //#endregion
 //#region src/cli/commands/lint/runner.ts
-function resolveConfigRunner(config) {
-	return normalizeConfig(config).reduce((merged, item) => item.runner ? {
-		...merged,
-		...item.runner
-	} : merged, void 0);
-}
-function resolveRunnerConfig(setupConfig, config, options) {
-	const cache = resolveRunnerCacheConfig(setupConfig.runner?.cache, config.runner?.cache, options);
-	const stats = resolveRunnerStatsConfig(setupConfig.runner?.stats, config.runner?.stats, options);
+/**
+* Applies this invocation's flags on top of the project's resolved runner.
+*
+* The setup/config merge itself lives in `runtime/runner.ts` because the language server needs the
+* same base without any flags; only the overrides below are CLI-shaped.
+*/
+function resolveRunnerConfig(baseRunner, options) {
 	const ruleConcurrency = parsePositiveIntegerOption(options.ruleConcurrency, "--rule-concurrency");
 	const timeoutMs = parsePositiveIntegerOption(options.timeoutMs, "--timeout-ms");
 	const runner = {
-		...setupConfig.runner ?? {},
-		...config.runner ?? {},
-		cache,
-		ruleConcurrency: ruleConcurrency ?? config.runner?.ruleConcurrency ?? setupConfig.runner?.ruleConcurrency,
-		stats,
-		timeoutMs: timeoutMs ?? config.runner?.timeoutMs ?? setupConfig.runner?.timeoutMs
+		...baseRunner ?? {},
+		cache: resolveCacheOption(baseRunner?.cache, options),
+		ruleConcurrency: ruleConcurrency ?? baseRunner?.ruleConcurrency,
+		stats: options.stats === false ? false : baseRunner?.stats,
+		timeoutMs: timeoutMs ?? baseRunner?.timeoutMs
 	};
 	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
 }
-function mergeRunnerCacheConfig(setupCache, configCache) {
-	if (configCache === void 0) return setupCache;
-	if (typeof configCache === "boolean") return configCache;
-	if (typeof setupCache === "object") return {
-		...setupCache,
-		...configCache
-	};
-	return configCache;
-}
-function mergeRunnerStatsConfig(setupStats, configStats) {
-	if (configStats === void 0) return setupStats;
-	if (typeof configStats === "boolean") return configStats;
-	if (typeof setupStats === "object") return {
-		...setupStats,
-		...configStats
-	};
-	return configStats;
-}
 function parsePositiveIntegerOption(value, label) {
 	if (value === void 0) return;
 	const parsed = Number(value);
 	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${label} must be a positive integer.`);
 	return parsed;
 }
-function resolveRunnerCacheConfig(setupCache, configCache, options) {
+function resolveCacheOption(baseCache, options) {
 	if (options.cache === false) return false;
-	const configuredCache = mergeRunnerCacheConfig(setupCache, configCache);
-	if (options.cacheLocation !== void 0) return typeof configuredCache === "object" ? {
-		...configuredCache,
+	if (options.cacheLocation !== void 0) return typeof baseCache === "object" ? {
+		...baseCache,
 		location: options.cacheLocation
 	} : { location: options.cacheLocation };
-	return configuredCache;
-}
-function resolveRunnerStatsConfig(setupStats, configStats, options) {
-	if (options.stats === false) return false;
-	return mergeRunnerStatsConfig(setupStats, configStats);
+	return baseCache;
 }
 //#endregion
 //#region src/cli/stats/ci.ts
@@ -3717,61 +3795,43 @@ function isNodeError(error) {
 }
 async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	if (options.config) await assertConfigExists(io.cwd, options.config);
-	const [{ defaultModel, setupConfig }, config] = await Promise.all([loadRunSetupConfig(io), loadAlintConfig(io.cwd, options.config)]);
-	let lintTargets;
+	const session = await createRunSession(io, { configPath: options.config });
 	try {
-		lintTargets = await findLintTargets({
-			config,
+		const runner = resolveRunnerConfig(session.runner, options);
+		const progress = shouldEnableProgress(options, io) ? createCliProgressReporter({
+			color: io.stderr.isTTY === true,
+			columns: io.stderr.columns ?? 80,
 			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,
-		columns: io.stderr.columns ?? 80,
-		cwd: io.cwd,
-		isTty: io.stderr.isTTY === true,
-		rows: io.stderr.rows,
-		write: (chunk) => io.stderr.write(chunk)
-	}) : void 0;
-	const restoreProgressConsole = progress ? interceptConsoleOutput({ write: progress.write }) : void 0;
-	const statsTarget = resolveStatsWrite(runner?.stats, io.env);
-	const statsCollector = statsTarget ? createStatsCollector() : void 0;
-	const persistStats = async (runResult) => {
-		if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, runResult, io.cwd);
-	};
-	const writeResult = (runResult) => {
-		io.stdout.write(formatDiagnostics(options.format, runResult, { color: io.stdout.isTTY === true }));
-	};
-	const runtime = await startModelAdapters(setupConfig, io);
-	let result;
-	try {
+			isTty: io.stderr.isTTY === true,
+			rows: io.stderr.rows,
+			write: (chunk) => io.stderr.write(chunk)
+		}) : void 0;
+		const restoreProgressConsole = progress ? interceptConsoleOutput({ write: progress.write }) : void 0;
+		const statsTarget = resolveStatsWrite(runner?.stats, io.env);
+		const statsCollector = statsTarget ? createStatsCollector() : void 0;
+		const persistStats = async (runResult) => {
+			if (statsTarget && statsCollector) await writeRunStats(statsTarget, statsCollector, runResult, io.cwd);
+		};
+		const writeResult = (runResult) => {
+			io.stdout.write(formatDiagnostics(options.format, runResult, { color: io.stdout.isTTY === true }));
+		};
+		let result;
 		try {
-			result = await runAlint({
+			result = await session.run({
 				cacheOnly: options.cacheOnly,
-				config,
-				cwd: io.cwd,
-				defaultModel,
-				directories: lintTargets.directories,
-				files: lintTargets.files,
+				files,
 				modelOverride: options.model,
 				outputLanguage: options.outputLanguage,
 				progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
-				runner,
-				setupConfig: runtime.setupConfig
+				runner
 			});
 		} catch (error) {
 			restoreProgressConsole?.();
 			progress?.dispose();
+			if (error instanceof NoFilesFoundError) {
+				io.stderr.write(`${error.message}\n`);
+				return 2;
+			}
 			if (error instanceof AlintRunError) {
 				await persistStats(error.result);
 				writeResult(error.result);
@@ -3792,7 +3852,7 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 		writeResult(result);
 		return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
 	} finally {
-		await runtime.shutdown();
+		await session.shutdown();
 	}
 }
 function shouldEnableProgress(options, io) {
@@ -3800,6 +3860,19 @@ function shouldEnableProgress(options, io) {
 	return options.format === "stylish" && io.stderr.isTTY === true;
 }
 //#endregion
+//#region src/cli/commands/lsp/index.ts
+const lsp = defineCommand({
+	action: async (context) => (await import("./server-DgJa6R5l.mjs")).startLspServer(context.io),
+	description: "Run alint as a language server over stdio",
+	examples: [["# Point an editor at the project's own alint", "alint lsp"].join("\n")],
+	help: ["Serve alint diagnostics over the Language Server Protocol on stdin/stdout.", "The server is cache-first: it publishes findings that are already cached and never calls a model on its own. Runs that spend tokens happen only through the `alint.runFile` and `alint.runWorkspace` commands."].join("\n\n"),
+	name: "lsp",
+	options: [{
+		description: "Use stdio transport (default; accepted for client compatibility)",
+		flags: "--stdio"
+	}]
+});
+//#endregion
 //#region src/cli/commands/output-inspect/inspect.ts
 const inspect$1 = defineCommand({
 	action: (context, file, options) => inspectOutputFile(context.io, file, options),
@@ -4459,6 +4532,7 @@ const commandTree = [
 			}
 		]
 	}),
+	lsp,
 	lint
 ];
 //#endregion
@@ -4545,4 +4619,4 @@ function shouldCaptureHelp(argv) {
 	return argv.includes("--help") || argv.includes("-h");
 }
 //#endregion
-export { formatJson as i, formatDiagnostics as n, formatStylish as r, executeCli as t };
+export { formatJson as a, formatStylish as i, createRunSession as n, formatDiagnostics as r, executeCli as t };

package/dist/index.d.mts

@@ -6,11 +6,19 @@ interface CliIo {
   cwd: string;
   env?: NodeJS.ProcessEnv;
   stderr: CliWritable;
-  stdin?: {
-    isTTY?: boolean;
-  };
+  stdin?: CliReadable;
   stdout: CliWritable;
 }
+/**
+ * A readable stream plus the TTY flag that the interactive commands read.
+ *
+ * `StreamMessageReader` in `vscode-jsonrpc` requires a full `NodeJS.ReadableStream`, so a narrower
+ * structural type does not compile. `PassThrough` satisfies it, which is how the protocol tests
+ * supply an in-memory stream.
+ */
+interface CliReadable extends NodeJS.ReadableStream {
+  isTTY?: boolean;
+}
 interface CliWritable {
   columns?: number;
   isTTY?: boolean;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-DFWnPI6m.mjs";
+import { a as formatJson, i as formatStylish, r as formatDiagnostics, t as executeCli } from "./cli-ChymU1Wr.mjs";
 import { ignorePatternsAIAgents, ignorePatternsBuildOutputs, ignorePatternsCaches, ignorePatternsCommon, ignorePatternsEslintDefaults, ignorePatternsGenerated } from "@alint-js/config";
 import { defineConfig } from "@alint-js/core";
 export { defineConfig, executeCli, formatDiagnostics, formatJson, formatStylish, ignorePatternsAIAgents, ignorePatternsBuildOutputs, ignorePatternsCaches, ignorePatternsCommon, ignorePatternsEslintDefaults, ignorePatternsGenerated };

package/dist/server-DgJa6R5l.mjs

@@ -0,0 +1,368 @@
+import { n as createRunSession } from "./cli-ChymU1Wr.mjs";
+import { realpath } from "node:fs/promises";
+import { AlintRunCancelledError, AlintRunError } from "@alint-js/core";
+import { join, relative, sep } from "node:path";
+import { errorMessageFrom } from "@moeru/std";
+import { Writable } from "node:stream";
+import { DidChangeWatchedFilesNotification } from "vscode-languageserver";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/cli/commands/lsp/diagnostics.ts
+/**
+* End column for a whole-line range.
+*
+* NOTICE: LSP clamps a character above the line length back to the line length, so the server can
+* mark a whole line without reading the file. Reading every file would cost a second pass over the
+* workspace. The value must stay inside `uinteger` (0..2^31-1), so it is not `MAX_SAFE_INTEGER`.
+* https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#position
+*/
+const WHOLE_LINE = 2147483647;
+/** alint reports 1-based lines and 0-based columns. LSP uses 0-based for both. */
+function toLspDiagnostic(diagnostic) {
+	return {
+		code: diagnostic.ruleId,
+		message: diagnostic.message,
+		range: toRange(diagnostic),
+		severity: diagnostic.severity === "error" ? 1 : 2,
+		source: "alint"
+	};
+}
+function toLineIndex(line) {
+	return Math.max(line - 1, 0);
+}
+function toRange(diagnostic) {
+	const { loc } = diagnostic;
+	if (!loc) return {
+		end: {
+			character: 0,
+			line: 0
+		},
+		start: {
+			character: 0,
+			line: 0
+		}
+	};
+	const line = toLineIndex(loc.start.line);
+	if (!loc.end) return {
+		end: {
+			character: WHOLE_LINE,
+			line
+		},
+		start: {
+			character: 0,
+			line
+		}
+	};
+	return {
+		end: {
+			character: loc.end.column,
+			line: toLineIndex(loc.end.line)
+		},
+		start: {
+			character: loc.start.column,
+			line
+		}
+	};
+}
+//#endregion
+//#region src/cli/commands/lsp/folder.ts
+/** One config write arrives as several filesystem events. Wait for them before running a pass. */
+const WORKSPACE_PASS_DEBOUNCE_MS = 500;
+/**
+* One workspace folder. It keeps two paths, and they are not interchangeable.
+*
+* Runs use `cwd`, the resolved path, because `process.cwd()` is always canonical and the lint
+* command therefore always runs under a resolved path. Under any other path each target gets a
+* different identity: the cache file is found, no entry matches, and no error is reported.
+*
+* Published diagnostics use `folderPath`, the path the client sent. See `toDocumentUri`.
+*/
+async function createFolderSession(options) {
+	const folderPath = fileURLToPath(options.folderUri);
+	const cwd = await realpath(folderPath);
+	const runIo = {
+		...options.io,
+		cwd
+	};
+	const paths = {
+		cwd,
+		folderPath
+	};
+	let session = await createRunSession(runIo);
+	let diagnostics = /* @__PURE__ */ new Map();
+	let scheduled;
+	const replaceMap = (next) => {
+		const changed = /* @__PURE__ */ new Set([...next.keys(), ...diagnostics.keys()]);
+		diagnostics = next;
+		return [...changed];
+	};
+	return {
+		cwd,
+		get diagnostics() {
+			return diagnostics;
+		},
+		dispose: async () => {
+			if (scheduled !== void 0) {
+				clearTimeout(scheduled);
+				scheduled = void 0;
+			}
+			await session.shutdown();
+		},
+		folderUri: options.folderUri,
+		refreshFile: async (uri) => {
+			const filePath = toRunPath(uri, paths);
+			if (filePath === void 0) return [];
+			const found = groupByUri(await runFromCache(session, { files: [filePath] }), paths);
+			const changed = /* @__PURE__ */ new Set([...found.keys()]);
+			const documentUri = toDocumentUri(filePath, paths);
+			if (!found.has(documentUri) && diagnostics.delete(documentUri)) changed.add(documentUri);
+			for (const [key, value] of found) diagnostics.set(key, value);
+			return [...changed];
+		},
+		refreshFromCache: async () => {
+			replaceMap(groupByUri(await runFromCache(session), paths));
+		},
+		reloadConfig: async () => {
+			const replaced = session;
+			session = await createRunSession(runIo);
+			await replaced.shutdown();
+		},
+		scheduleWorkspacePass: () => {
+			if (scheduled !== void 0) return;
+			scheduled = setTimeout(() => {
+				scheduled = void 0;
+				(async () => {
+					try {
+						options.onChanged?.(replaceMap(groupByUri(await runFromCache(session), paths)));
+					} catch (error) {
+						options.io.stderr.write(`alint lsp: workspace pass failed: ${errorMessageFrom(error) ?? "unknown error"}\n`);
+					}
+				})();
+			}, WORKSPACE_PASS_DEBOUNCE_MS);
+		}
+	};
+}
+/** A project rule reports diagnostics for files it did not target, so group by the named file. */
+function groupByUri(result, paths) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const diagnostic of result.diagnostics) {
+		const uri = toDocumentUri(diagnostic.filePath, paths);
+		const existing = grouped.get(uri);
+		if (existing) {
+			existing.push(toLspDiagnostic(diagnostic));
+			continue;
+		}
+		grouped.set(uri, [toLspDiagnostic(diagnostic)]);
+	}
+	return grouped;
+}
+async function runFromCache(session, options = {}) {
+	try {
+		return await session.run({
+			cacheOnly: true,
+			files: options.files,
+			projectTargets: options.files === void 0 ? void 0 : false,
+			runner: {
+				...session.runner,
+				stats: false
+			}
+		});
+	} catch (error) {
+		if (error instanceof AlintRunError || error instanceof AlintRunCancelledError) return error.result;
+		throw error;
+	}
+}
+/**
+* Converts a run path back to the path the client sent.
+*
+* An editor matches diagnostics by exact URI. A resolved URI attaches them to a document the editor
+* did not open.
+*/
+function toDocumentUri(filePath, paths) {
+	if (paths.cwd === paths.folderPath || !filePath.startsWith(`${paths.cwd}${sep}`)) return pathToFileURL(filePath).toString();
+	return pathToFileURL(join(paths.folderPath, relative(paths.cwd, filePath))).toString();
+}
+/**
+* Converts a document URI into the path a run uses. The inverse of `toDocumentUri`.
+*
+* Returns undefined for a URI outside this folder. A server with several folders uses that to find
+* the folder that owns the file.
+*/
+function toRunPath(uri, paths) {
+	const filePath = fileURLToPath(uri);
+	if (!filePath.startsWith(`${paths.folderPath}${sep}`)) return;
+	return join(paths.cwd, relative(paths.folderPath, filePath));
+}
+//#endregion
+//#region src/cli/commands/lsp/publisher.ts
+/**
+* Collects document URIs and publishes each one once per window, open documents first.
+*
+* An LSP publish carries a whole document, so one publish per finding would send the same document
+* many times. A workspace pass can queue thousands of documents, and the open one must not wait
+* for the rest.
+*/
+function createPublisher(options) {
+	const open = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Set();
+	let timer;
+	const flush = () => {
+		timer = void 0;
+		const uris = [...pending];
+		pending.clear();
+		for (const uri of uris.filter((uri) => open.has(uri))) options.publish(uri);
+		for (const uri of uris.filter((uri) => !open.has(uri))) options.publish(uri);
+	};
+	return {
+		dispose: () => {
+			if (timer !== void 0) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+			pending.clear();
+		},
+		isOpen: (uri) => open.has(uri),
+		queue: (uri) => {
+			pending.add(uri);
+			timer ??= setTimeout(flush, options.flushMs);
+		},
+		setOpen: (uri, isOpen) => {
+			if (isOpen) {
+				open.add(uri);
+				return;
+			}
+			open.delete(uri);
+		}
+	};
+}
+//#endregion
+//#region src/cli/commands/lsp/server.ts
+/** Long enough to collect a workspace pass into few messages, short enough to keep a save prompt. */
+const PUBLISH_FLUSH_MS = 200;
+/** Two commands, because a workspace run can cost orders of magnitude more than one file. */
+const RUN_FILE_COMMAND = "alint.runFile";
+const RUN_WORKSPACE_COMMAND = "alint.runWorkspace";
+async function startLspServer(io) {
+	const { stdin } = io;
+	if (!stdin) {
+		io.stderr.write("alint lsp needs a readable stdin to speak JSON-RPC over.\n");
+		return 2;
+	}
+	const { createConnection, TextDocumentSyncKind } = await import("vscode-languageserver/node");
+	const connection = createConnection(stdin, toWritableStream(io.stdout));
+	const folders = /* @__PURE__ */ new Map();
+	let folderUris = [];
+	let watchesConfig = false;
+	/** A document belongs to one folder at most, so the first folder that holds it is the owner. */
+	const diagnosticsFor = (uri) => {
+		for (const folder of folders.values()) {
+			const diagnostics = folder.diagnostics.get(uri);
+			if (diagnostics) return diagnostics;
+		}
+		return [];
+	};
+	const publisher = createPublisher({
+		flushMs: PUBLISH_FLUSH_MS,
+		publish: (uri) => connection.sendDiagnostics({
+			diagnostics: diagnosticsFor(uri),
+			uri
+		})
+	});
+	const openFolder = async (folderUri) => {
+		const folder = await createFolderSession({
+			folderUri,
+			io,
+			onChanged: (uris) => uris.forEach(publisher.queue)
+		});
+		folders.set(folderUri, folder);
+		await folder.refreshFromCache();
+		for (const uri of folder.diagnostics.keys()) publisher.queue(uri);
+	};
+	connection.onInitialize((params) => {
+		folderUris = resolveFolderUris(params);
+		watchesConfig = params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
+		return { capabilities: {
+			executeCommandProvider: {
+				commands: [RUN_FILE_COMMAND, RUN_WORKSPACE_COMMAND],
+				workDoneProgress: true
+			},
+			textDocumentSync: {
+				change: TextDocumentSyncKind.None,
+				openClose: true,
+				save: true
+			},
+			workspace: { workspaceFolders: {
+				changeNotifications: true,
+				supported: true
+			} }
+		} };
+	});
+	connection.onInitialized(() => {
+		if (watchesConfig) connection.client.register(DidChangeWatchedFilesNotification.type, { watchers: [{ globPattern: "**/alint.config.*" }] });
+		Promise.all(folderUris.map(async (folderUri) => {
+			try {
+				await openFolder(folderUri);
+			} catch (error) {
+				connection.console.error(`alint: ${folderUri}: ${errorMessageFrom(error) ?? "could not read cached diagnostics"}`);
+			}
+		}));
+	});
+	connection.onDidSaveTextDocument(({ textDocument }) => {
+		Promise.all([...folders.values()].map(async (folder) => {
+			try {
+				for (const uri of await folder.refreshFile(textDocument.uri)) publisher.queue(uri);
+			} catch (error) {
+				connection.console.error(`alint: ${textDocument.uri}: ${errorMessageFrom(error) ?? "could not refresh the saved file"}`);
+			}
+		}));
+	});
+	connection.onDidOpenTextDocument(({ textDocument }) => {
+		publisher.setOpen(textDocument.uri, true);
+		publisher.queue(textDocument.uri);
+	});
+	connection.onDidCloseTextDocument(({ textDocument }) => {
+		publisher.setOpen(textDocument.uri, false);
+	});
+	connection.onDidChangeWatchedFiles(() => {
+		Promise.all([...folders.values()].map(async (folder) => {
+			try {
+				await folder.reloadConfig();
+				folder.scheduleWorkspacePass();
+			} catch (error) {
+				connection.console.error(`alint: ${folder.folderUri}: ${errorMessageFrom(error) ?? "could not reload the config"}`);
+			}
+		}));
+		connection.console.info("alint: config changed; cached diagnostics were cleared and need a new run");
+	});
+	connection.onShutdown(async () => {
+		publisher.dispose();
+		await Promise.all([...folders.values()].map((folder) => folder.dispose()));
+		folders.clear();
+	});
+	connection.listen();
+	return new Promise((resolve) => {
+		connection.onExit(() => resolve(0));
+	});
+}
+/**
+* A client can send `workspaceFolders`, the older `rootUri`, or both.
+*
+* Only a `file:` URI has a directory. A remote or untitled root has no cwd and no cache.
+*/
+function resolveFolderUris(params) {
+	const uris = params.workspaceFolders?.map((folder) => folder.uri) ?? (params.rootUri === null ? [] : [params.rootUri]);
+	return [...new Set(uris)].filter((uri) => uri.startsWith("file://"));
+}
+/**
+* Adapts the CLI string output to the byte stream that `createConnection` requires.
+*
+* `String(chunk)` cannot split a UTF-8 sequence here. The message writer sends one ASCII header,
+* then one complete body, so every chunk is whole.
+*/
+function toWritableStream(sink) {
+	return new Writable({ write(chunk, _encoding, callback) {
+		sink.write(String(chunk));
+		callback();
+	} });
+}
+//#endregion
+export { startLspServer };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -28,9 +28,10 @@
     "pathe": "^2.0.3",
     "table": "^6.9.0",
     "tinyrainbow": "^3.1.1",
-    "@alint-js/model-adapter-acp": "0.4.0",
-    "@alint-js/core": "0.4.0",
-    "@alint-js/config": "0.4.0"
+    "vscode-languageserver": "^10.1.0",
+    "@alint-js/config": "0.5.0",
+    "@alint-js/core": "0.5.0",
+    "@alint-js/model-adapter-acp": "0.5.0"
   },
   "devDependencies": {
     "@pnpm/find-workspace-dir": "^1000.1.5",