@alint-js/cli 0.3.2 → 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.
@@ -244,6 +281,35 @@ thinking = { type = "disabled" }
 
 `default_params` is merged into every chat request for that model. Use it for provider-specific request fields that are not covered by the rest of the model entry.
 
+The CLI can also launch an ACP coding-agent command and expose it to rules as an ordinary model. Interactive `alint setup` provides presets for Claude Code, Codex, Gemini CLI, Kimi Code CLI, and OpenCode. Put a custom machine-specific command in the global setup config, or in `.alint/config.toml` when the repository standardizes the same command for every contributor:
+
+```toml
+version = 1
+
+[[providers]]
+id = "acp"
+
+[[providers.models]]
+id = "codex"
+name = "Codex ACP"
+driver = "acp"
+aliases = [ "default" ]
+capabilities = [ "tool-call" ]
+command = "codex-acp"
+args = []
+cwd = "."
+```
+
+Then select it like any other model:
+
+```bash
+alint --model acp/codex src
+```
+
+`alint.config.ts` remains the shareable lint policy: it selects models, plugins, and rules but does not launch processes. The CLI merges global setup with `.alint/config.toml`, starts a loopback OpenAI-compatible adapter for the run, and shuts it down afterward. Each concurrent model request gets its own ACP process, so `--rule-concurrency` also bounds how many coding-agent processes a run can require.
+
+The command inherits the environment that launched `alint`. Optional `[providers.models.env]` entries override individual variables, but setup TOML does not interpolate variables. Do not commit credentials into the table. Request tools require the ACP agent to support MCP over HTTP.
+
 `alint` structured output forces a tool call (`tool_choice`). Some models, such as DeepSeek V4, reject that combination while thinking/reasoning is enabled. For those models, set `thinking = { type = "disabled" }` as above so structured output can run.
 
 Note that `-N` stands for `--no-interactive`, which means this is not an interactive setup. TUI is not required, so you can ask Codex or Claude Code to run this command for you.

package/dist/bin/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as executeCli } from "../cli-CP8pWPS7.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-CP8pWPS7.mjs → cli-ChymU1Wr.mjs}

@@ -2,12 +2,13 @@ import process from "node:process";
 import { inspect } from "node:util";
 import { cac } from "cac";
 import { appendFile, mkdir, opendir, readFile, readdir, rm, stat } from "node:fs/promises";
-import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
+import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, isAcpModel, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, normalizeSetupConfig, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
 import { AlintRunCancelledError, AlintRunError, benchmarkModels, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, resolveConfigForDirectory, resolveConfigForFile, runAlint } from "@alint-js/core";
 import { isAbsolute, join, relative, resolve } from "pathe";
 import { errorMessageFrom } from "@moeru/std/error";
 import { getBorderCharacters, table } from "table";
 import { createColors } from "tinyrainbow";
+import { createCommandModel, startGateway } from "@alint-js/model-adapter-acp";
 import cliSpinners from "cli-spinners";
 import fastStringWidth from "fast-string-width";
 import { relative as relative$1 } from "node:path";
@@ -17,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.3.2";
+var version = "0.5.0";
 //#endregion
 //#region src/cli/output.ts
 function escapeLineValue(value) {
@@ -46,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];
@@ -169,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;
@@ -296,12 +311,14 @@ const providerSetupSources = [
 		benchmarkConcurrency: 2,
 		defaultEndpoint: "http://127.0.0.1:8317/v1",
 		defaultProviderId: "CLIProxyAPI",
+		kind: "openai-compatible",
 		label: "CLIProxyAPI",
 		probeModels: true,
 		value: "cliProxyApi"
 	},
 	{
 		benchmarkConcurrency: 2,
+		kind: "openai-compatible",
 		label: "Custom OpenAI-compatible provider",
 		probeModels: true,
 		value: "custom"
@@ -310,6 +327,7 @@ const providerSetupSources = [
 		benchmarkConcurrency: 20,
 		defaultEndpoint: "https://openrouter.ai/api/v1",
 		defaultProviderId: "openrouter",
+		kind: "openai-compatible",
 		label: "OpenRouter",
 		probeModels: true,
 		value: "openrouter"
@@ -318,6 +336,7 @@ const providerSetupSources = [
 		benchmarkConcurrency: 2,
 		defaultEndpoint: "https://api.cerebras.ai/v1",
 		defaultProviderId: "cerebras",
+		kind: "openai-compatible",
 		label: "Cerebras",
 		probeModels: true,
 		value: "cerebras"
@@ -326,6 +345,7 @@ const providerSetupSources = [
 		benchmarkConcurrency: 2,
 		defaultEndpoint: "https://api.groq.com/openai/v1",
 		defaultProviderId: "groq",
+		kind: "openai-compatible",
 		label: "Groq",
 		probeModels: true,
 		value: "groq"
@@ -333,15 +353,81 @@ const providerSetupSources = [
 	{
 		benchmarkConcurrency: 2,
 		defaultEndpoint: "http://localhost:11434/v1",
+		kind: "openai-compatible",
 		label: "Ollama",
 		probeModels: true,
 		value: "ollama"
 	},
 	{
 		benchmarkConcurrency: 2,
+		kind: "openai-compatible",
 		label: "Manual model entry",
 		probeModels: false,
 		value: "manual"
+	},
+	{
+		args: ["-y", "@agentclientprotocol/claude-agent-acp"],
+		command: "npx",
+		defaultProviderId: "claude-code",
+		kind: "acp",
+		label: "Claude Code (ACP)",
+		model: {
+			id: "claude-code",
+			name: "Claude Code"
+		},
+		value: "claudeCodeAcp"
+	},
+	{
+		args: ["-y", "@agentclientprotocol/codex-acp"],
+		command: "npx",
+		defaultProviderId: "codex",
+		kind: "acp",
+		label: "Codex (ACP)",
+		model: {
+			id: "codex",
+			name: "Codex"
+		},
+		value: "codexAcp"
+	},
+	{
+		args: [
+			"-y",
+			"@google/gemini-cli",
+			"--acp"
+		],
+		command: "npx",
+		defaultProviderId: "gemini-cli",
+		kind: "acp",
+		label: "Gemini CLI (ACP)",
+		model: {
+			id: "gemini-cli",
+			name: "Gemini CLI"
+		},
+		value: "geminiCliAcp"
+	},
+	{
+		args: ["acp"],
+		command: "kimi",
+		defaultProviderId: "kimi-code",
+		kind: "acp",
+		label: "Kimi Code CLI (ACP)",
+		model: {
+			id: "kimi-code",
+			name: "Kimi Code CLI"
+		},
+		value: "kimiCliAcp"
+	},
+	{
+		args: ["acp"],
+		command: "opencode",
+		defaultProviderId: "opencode",
+		kind: "acp",
+		label: "OpenCode (ACP)",
+		model: {
+			id: "opencode",
+			name: "OpenCode"
+		},
+		value: "openCodeAcp"
 	}
 ];
 function buildModelsUrl(endpoint) {
@@ -379,7 +465,7 @@ function findProviderSetupSource(value) {
 }
 function findProviderSetupSourceByEndpoint(endpoint) {
 	const normalizedEndpoint = endpoint instanceof URL ? endpoint.toString() : new URL(endpoint).toString();
-	return providerSetupSources.find((source) => source.defaultEndpoint !== void 0 && new URL(source.defaultEndpoint).toString() === normalizedEndpoint);
+	return providerSetupSources.find((source) => source.kind === "openai-compatible" && source.defaultEndpoint !== void 0 && new URL(source.defaultEndpoint).toString() === normalizedEndpoint);
 }
 function flattenModels(config) {
 	return config.providers.flatMap((provider) => provider.models.map((model) => ({
@@ -520,16 +606,16 @@ function formatProviderList(config) {
 		"models"
 	], ...config.providers.map((provider) => [
 		provider.id,
-		provider.type,
-		provider.endpoint,
+		provider.type ?? "model-driven",
+		provider.endpoint ?? "-",
 		String(provider.models.length)
 	])]);
 }
 function formatProviderShow(provider) {
 	const lines = [
 		`id: ${provider.id}`,
-		`type: ${provider.type}`,
-		`endpoint: ${provider.endpoint}`,
+		`type: ${provider.type ?? "model-driven"}`,
+		`endpoint: ${provider.endpoint ?? "-"}`,
 		`models: ${provider.models.map((model) => model.id).join(", ")}`
 	];
 	const headerKeys = Object.keys(provider.headers ?? {});
@@ -560,7 +646,7 @@ async function probeModels(endpoint, headers = {}) {
 	return body.data.map((model) => model.id);
 }
 function resolveProviderBenchmarkConcurrency(config, overrides = []) {
-	const concurrency = Object.fromEntries(config.providers.map((provider) => [provider.id, findProviderSetupSourceByEndpoint(provider.endpoint)?.benchmarkConcurrency ?? defaultBenchmarkConcurrency]));
+	const concurrency = Object.fromEntries(config.providers.map((provider) => [provider.id, provider.endpoint === void 0 ? defaultBenchmarkConcurrency : findProviderSetupSourceByEndpoint(provider.endpoint)?.benchmarkConcurrency ?? defaultBenchmarkConcurrency]));
 	for (const override of overrides) {
 		const separatorIndex = override.indexOf("=");
 		if (separatorIndex <= 0 || separatorIndex === override.length - 1) throw new Error("Invalid benchmark concurrency override. Expected <provider-id>=<limit>.");
@@ -645,6 +731,89 @@ function stripTrailingZeros(value) {
 	return String(Number(value));
 }
 //#endregion
+//#region src/cli/runtime/model-adapter.ts
+/**
+* Normalizes file configuration and starts its model adapters.
+*
+* Triggering workflow:
+*
+* `runLintCommand | runListModelsCommand`
+*   -> {@link startModelAdapters}
+*     -> {@link createAcpAdapter}
+*       -> {@link normalizeSetupConfig}
+*         -> `AcpAdapter.provider`
+*           -> {@link startGateway}
+*
+* Upstream:
+* - `runLintCommand`
+* - `runListModelsCommand`
+*
+* Downstream:
+* - {@link normalizeSetupConfig}
+* - {@link startGateway}
+*/
+async function startModelAdapters(config, io) {
+	const acp = createAcpAdapter(io);
+	try {
+		return {
+			setupConfig: await normalizeSetupConfig(config, { acp: acp.provider }),
+			shutdown: acp.shutdown
+		};
+	} catch (error) {
+		await acp.shutdown();
+		throw error;
+	}
+}
+/** Owns the ACP processes and loopback gateways used by one CLI operation. */
+function createAcpAdapter(io) {
+	const shutdowns = [];
+	return {
+		provider: async (provider) => {
+			const gateway = await startGateway({
+				cwd: io.cwd,
+				models: provider.models.map((model) => createCommandModel({
+					args: model.args,
+					command: model.command,
+					cwd: resolve(io.cwd, model.cwd ?? "."),
+					env: {
+						...io.env ?? process.env,
+						...model.env
+					},
+					id: model.id,
+					name: model.name ?? model.id,
+					onStderr: createStderrWriter(io, model.id)
+				}))
+			});
+			shutdowns.push(gateway.shutdown);
+			return {
+				endpoint: gateway.endpoint,
+				type: "openai-compatible"
+			};
+		},
+		shutdown: async () => {
+			await Promise.all(shutdowns.map((shutdown) => shutdown()));
+		}
+	};
+}
+/**
+* Creates the CLI stderr sink for non-protocol output emitted by an ACP command.
+*
+* Triggering workflow:
+*
+* {@link createCommandModel}
+*   -> `ChildProcess.stderr:data`
+*     -> {@link createStderrWriter}
+*
+* Upstream:
+* - {@link createAcpAdapter}
+*
+* Downstream:
+* - {@link CliIo.stderr}
+*/
+function createStderrWriter(io, modelId) {
+	return (text) => io.stderr.write(`[acp:${modelId}] ${text}`);
+}
+//#endregion
 //#region src/cli/commands/config/setup-config.ts
 function formatUnknownProvider(providerId, scope) {
 	const hint = scope === "local" ? " Remove --local to inspect global configuration." : " Add --local to inspect project-local configuration.";
@@ -820,19 +989,21 @@ async function runListModelsCommand(context, options) {
 		context.io.stderr.write(`${errorMessageFrom(error) ?? "Invalid benchmark concurrency override."}\n`);
 		return 2;
 	}
+	const runtime = await startModelAdapters(config, context.io);
 	const progress = context.io.stderr.isTTY === true ? createModelBenchmarkProgressDisplay({
 		color: true,
-		config,
+		config: runtime.setupConfig,
 		output: context.io.stderr
 	}) : void 0;
 	let benchmarks;
 	try {
-		benchmarks = await benchmarkModels(config, {
+		benchmarks = await benchmarkModels(runtime.setupConfig, {
 			onProgress: (snapshot) => progress?.update(snapshot),
 			providerConcurrency
 		});
 	} finally {
 		progress?.finish();
+		await runtime.shutdown();
 	}
 	context.io.stdout.write(formatModelBenchmarkList(config, benchmarks, { color: context.io.stdout.isTTY === true }));
 	return 0;
@@ -941,15 +1112,21 @@ async function runPruneModelsCommand(context, options, confirm = confirmPruneMod
 	const plans = [];
 	let hadFailure = false;
 	for (const provider of providers) {
+		const endpoint = provider.endpoint;
+		if (endpoint === void 0) {
+			hadFailure = true;
+			context.io.stderr.write(`cannot prune provider "${escapeLineValue(provider.id)}" because it has no remote endpoint.\n`);
+			continue;
+		}
 		let remoteModelIds;
 		try {
-			remoteModelIds = new Set(await probeModels(provider.endpoint, provider.headers));
+			remoteModelIds = new Set(await probeModels(endpoint, provider.headers));
 		} catch (error) {
 			hadFailure = true;
-			context.io.stderr.write(`failed to probe provider "${escapeLineValue(provider.id)}" at "${escapeLineValue(provider.endpoint)}": ${classifyProbeFailure(error)}.\n`);
+			context.io.stderr.write(`failed to probe provider "${escapeLineValue(provider.id)}" at "${escapeLineValue(endpoint)}": ${classifyProbeFailure(error)}.\n`);
 			continue;
 		}
-		const removedModels = provider.models.filter((model) => !remoteModelIds.has(model.id));
+		const removedModels = provider.models.filter((model) => !isAcpModel(model) && !remoteModelIds.has(model.id));
 		const defaultModel = removedModels.find((model) => (model.aliases ?? []).includes("default"));
 		if (defaultModel !== void 0) {
 			hadFailure = true;
@@ -1669,6 +1846,7 @@ function textResult(prompts, result) {
 */
 async function runProviderEditor(input, promptPort) {
 	const prompts = promptPort ?? createProviderEditorPrompts(await import("@clack/prompts"));
+	if (input.source.kind === "acp") return runAcpProviderEditor(input, input.source, prompts);
 	const existingProvider = input.mode === "update" ? input.existingProvider : void 0;
 	const configuredHeaders = { ...existingProvider?.headers };
 	const initialHeaders = applyHeaderSelection(configuredHeaders, Object.keys(configuredHeaders), {}) ?? {};
@@ -1800,6 +1978,30 @@ async function runProviderEditor(input, promptPort) {
 		};
 	}
 }
+function createAcpProvider(source, providerId) {
+	return {
+		id: providerId,
+		models: [{
+			...source.args === void 0 ? {} : { args: [...source.args] },
+			capabilities: ["tool-call"],
+			command: source.command,
+			driver: "acp",
+			...source.model
+		}]
+	};
+}
+function createAcpSummary(input, provider, defaultAliasTarget) {
+	const model = provider.models[0];
+	return [
+		`${input.mode === "create" ? "Create" : "Update"} provider?`,
+		`Provider: ${escapeLineValue(provider.id)}`,
+		"Driver: ACP",
+		`Command: ${escapeLineValue("command" in model ? model.command : "-")}`,
+		`Arguments: ${"args" in model ? formatSummaryValues(model.args ?? []) : "(none)"}`,
+		`Model: ${escapeLineValue(model.id)}`,
+		`Default: ${defaultAliasTarget === void 0 ? "unchanged" : escapeLineValue(`${defaultAliasTarget.providerId}/${defaultAliasTarget.modelId}`)}`
+	].join("\n");
+}
 function createProvider(input, draft) {
 	return {
 		...input.existingProvider,
@@ -1819,7 +2021,7 @@ function createSummary(input, provider, defaultAliasTarget) {
 	return [
 		`${input.mode === "create" ? "Create" : "Update"} provider?`,
 		`Provider: ${escapeLineValue(provider.id)}`,
-		`Endpoint: ${escapeLineValue(provider.endpoint)}`,
+		`Endpoint: ${escapeLineValue(provider.endpoint ?? "-")}`,
 		`Headers: ${formatSummaryValues(Object.keys(provider.headers ?? {}))}`,
 		`Added models: ${formatSummaryValues(additions)}`,
 		`Removed models: ${formatSummaryValues(removals)}`,
@@ -1832,6 +2034,87 @@ function effectiveHeaders(draft) {
 function formatSummaryValues(values) {
 	return values.length > 0 ? values.map(escapeLineValue).join(", ") : "(none)";
 }
+/**
+* Runs the preset-backed ACP branch of the provider editor.
+*
+* Triggering workflow:
+*
+* {@link runInteractiveSetup}
+*   -> {@link runProviderEditor}
+*     -> `provider-editor.acp-preset`
+*       -> {@link runAcpProviderEditor}
+*
+* Upstream:
+* - {@link runProviderEditor}
+*
+* Downstream:
+* - {@link ProviderEditorResult} and the caller-owned setup-config write
+*/
+async function runAcpProviderEditor(input, source, prompts) {
+	let defaultAliasTarget;
+	let providerId = input.existingProvider?.id ?? source.defaultProviderId;
+	let step = "providerId";
+	while (true) {
+		if (step === "providerId") {
+			const result = await prompts.providerId(providerId, input.mode === "create");
+			if (result.status === "cancelled") return { status: "cancelled" };
+			if (result.status === "back") return { status: "back" };
+			providerId = result.value.trim();
+			step = "defaultAction";
+			continue;
+		}
+		const provider = createAcpProvider(source, providerId);
+		if (step === "defaultAction") {
+			const result = await prompts.defaultAction(source.model.id);
+			if (result.status === "cancelled") return { status: "cancelled" };
+			if (result.status === "back") {
+				step = "providerId";
+				continue;
+			}
+			defaultAliasTarget = result.value === "yes" ? {
+				modelId: source.model.id,
+				providerId
+			} : void 0;
+			step = result.value === "selectAnother" ? "defaultModel" : "confirm";
+			continue;
+		}
+		if (step === "defaultModel") {
+			const candidates = createDefaultModelCandidates(mergeSetupConfigs(input.config, {
+				providers: [provider],
+				version: 1
+			}), provider.id, [source.model.id]);
+			const selectedDefault = await prompts.defaultModel(candidates.map((candidate) => ({
+				hint: candidate.isCurrentDefault ? "current default" : candidate.isNew ? "new" : void 0,
+				label: candidate.label,
+				value: candidate.value
+			})));
+			if (selectedDefault.status === "cancelled") return { status: "cancelled" };
+			if (selectedDefault.status === "back") {
+				step = "defaultAction";
+				continue;
+			}
+			const candidate = candidates.find((item) => item.value === selectedDefault.value);
+			if (candidate === void 0) return { status: "cancelled" };
+			defaultAliasTarget = {
+				modelId: candidate.modelId,
+				providerId: candidate.providerId
+			};
+			step = "confirm";
+			continue;
+		}
+		const confirmed = await prompts.confirm(createAcpSummary(input, provider, defaultAliasTarget));
+		if (confirmed.status === "cancelled" || confirmed.status === "submitted" && confirmed.value === "no") return { status: "cancelled" };
+		if (confirmed.status === "back") {
+			step = "defaultAction";
+			continue;
+		}
+		return {
+			...defaultAliasTarget === void 0 ? {} : { defaultAliasTarget },
+			provider,
+			status: "confirmed"
+		};
+	}
+}
 function splitInput(value) {
 	return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
@@ -1885,6 +2168,11 @@ function mergeProviderHeaders(existing, replacements) {
 	return Object.keys(headers).length > 0 ? headers : void 0;
 }
 async function runNonInteractiveUpdate(context, options, providerEndpoint, existingProvider, config, path) {
+	const endpoint = providerEndpoint ?? existingProvider.endpoint;
+	if (endpoint === void 0) {
+		context.io.stderr.write(`provider "${existingProvider.id}" has no remote endpoint to update.\n`);
+		return 2;
+	}
 	let parsedHeaders;
 	try {
 		parsedHeaders = parseHeaderList(toArray$1(options.providerHeader));
@@ -1894,12 +2182,12 @@ async function runNonInteractiveUpdate(context, options, providerEndpoint, exist
 	}
 	const draft = {
 		...existingProvider,
-		endpoint: providerEndpoint ?? existingProvider.endpoint,
+		endpoint,
 		headers: mergeProviderHeaders(existingProvider.headers, parsedHeaders)
 	};
 	let remoteModelIds;
 	try {
-		remoteModelIds = await probeModels(draft.endpoint, draft.headers);
+		remoteModelIds = await probeModels(endpoint, draft.headers);
 	} catch (error) {
 		context.io.stderr.write(`failed to probe provider: ${errorMessageFrom(error) ?? "Unknown error."}\n`);
 		return 2;
@@ -1947,13 +2235,21 @@ async function runUpdateProviderCommand(context, options) {
 		context.io.stderr.write(formatUnknownProvider(providerId, scope));
 		return 2;
 	}
+	const endpoint = providerEndpoint ?? existingProvider.endpoint;
+	if (endpoint === void 0) {
+		context.io.stderr.write(`provider "${existingProvider.id}" has no remote endpoint to update.\n`);
+		return 2;
+	}
 	if (context.setupNoInteractive) return runNonInteractiveUpdate(context, options, providerEndpoint, existingProvider, config, path);
 	const result = await runProviderEditor({
 		config,
-		existingProvider,
+		existingProvider: {
+			...existingProvider,
+			endpoint
+		},
 		io: context.io,
 		mode: "update",
-		source: providerUpdateSource(existingProvider.endpoint)
+		source: providerUpdateSource(endpoint)
 	});
 	if (result.status !== "confirmed") return 0;
 	const replaced = replaceSetupProvider(config, result.provider);
@@ -2806,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) {
@@ -2873,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
@@ -3435,84 +3795,84 @@ 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;
+			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 session.run({
+				cacheOnly: options.cacheOnly,
+				files,
+				modelOverride: options.model,
+				outputLanguage: options.outputLanguage,
+				progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
+				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);
+				io.stderr.write(formatRunError(error, io.stderr.isTTY === true));
+				return 2;
+			}
+			if (error instanceof AlintRunCancelledError) {
+				await persistStats(error.result);
+				writeResult(error.result);
+				io.stderr.write(formatCancelledError(error, io.stderr.isTTY === true));
+				return 2;
+			}
+			throw error;
 		}
-		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 }));
-	};
-	let result;
-	try {
-		result = await runAlint({
-			cacheOnly: options.cacheOnly,
-			config,
-			cwd: io.cwd,
-			defaultModel,
-			directories: lintTargets.directories,
-			files: lintTargets.files,
-			modelOverride: options.model,
-			outputLanguage: options.outputLanguage,
-			progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
-			runner,
-			setupConfig
-		});
-	} catch (error) {
 		restoreProgressConsole?.();
 		progress?.dispose();
-		if (error instanceof AlintRunError) {
-			await persistStats(error.result);
-			writeResult(error.result);
-			io.stderr.write(formatRunError(error, io.stderr.isTTY === true));
-			return 2;
-		}
-		if (error instanceof AlintRunCancelledError) {
-			await persistStats(error.result);
-			writeResult(error.result);
-			io.stderr.write(formatCancelledError(error, io.stderr.isTTY === true));
-			return 2;
-		}
-		throw error;
+		await persistStats(result);
+		writeResult(result);
+		return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
+	} finally {
+		await session.shutdown();
 	}
-	restoreProgressConsole?.();
-	progress?.dispose();
-	await persistStats(result);
-	writeResult(result);
-	return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
 }
 function shouldEnableProgress(options, io) {
 	if (options.progress !== void 0) return options.progress;
 	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),
@@ -4172,6 +4532,7 @@ const commandTree = [
 			}
 		]
 	}),
+	lsp,
 	lint
 ];
 //#endregion
@@ -4258,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-CP8pWPS7.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.3.2",
+  "version": "0.5.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -28,8 +28,10 @@
     "pathe": "^2.0.3",
     "table": "^6.9.0",
     "tinyrainbow": "^3.1.1",
-    "@alint-js/core": "0.3.2",
-    "@alint-js/config": "0.3.2"
+    "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",