@alint-js/cli 0.3.1 → 0.4.0

package/README.md

@@ -167,6 +167,8 @@ Override the matched model for a one-off run:
 alint --model qwen:8b demo.ts
 ```
 
+When the project-local setup does not configure any models, model calls without a rule-level or call-level selector use the `default` alias from the global setup. Rule selectors continue to use normal model matching. Configuring at least one model in `.alint/config.toml` restores project-first matching for unselected calls. An explicit `--model` override always takes precedence.
+
 Ask model-backed rules to write diagnostics in a specific language:
 
 ```bash
@@ -213,18 +215,12 @@ alint output inspect alint-output.json
 
 #### Configurations
 
-In order to provision models and LLMs for `alint` while keeping it clean for contributors of your project without requiring them to set up their own LLMs, `alint` offers layers of configuration covering **Project Local**, **Global**, project config, and environment or CLI overrides.
-
-The priorities follow:
-
-```text
-~/.config/alint/config.toml < .alint/config.toml < alint.config.* < environment and CLI overrides
-```
+`alint` uses two configuration systems with separate schemas and responsibilities:
 
-- `~/.config/alint/config.toml` stores user-level provider setup.
-- `.alint/config.toml` stores optional project-local provider setup.
-- `alint.config.*` stores project lint config, plugins, files, ignores, and rule settings.
-- Environment variables and CLI flags are the highest-priority overrides.
+| Configuration | Priority (high → low)                                                                | Content                                                              |
+| --- |--------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| Setup | Environment and CLI overrides > `.alint/config.toml` > `~/.config/alint/config.toml` | Providers, models, and runner defaults.                              |
+| Lint | Environment and CLI overrides > `alint.config.*`                                     | Files, ignores, plugins, rules, and other project-level lint policy. |
 
 Use setup TOML for machine or project provider definitions:
 
@@ -241,8 +237,44 @@ id = "qwen:8b"
 name = "qwen:8b"
 size = "small"
 capabilities = [ "tool-call" ]
+
+[providers.models.default_params]
+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.
 
 You can also use `--local` to write the config in the current project:

package/dist/bin/index.mjs

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

package/dist/{cli-CL433bER.mjs → cli-DFWnPI6m.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.1";
+var version = "0.4.0";
 //#endregion
 //#region src/cli/output.ts
 function escapeLineValue(value) {
@@ -296,12 +297,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 +313,7 @@ const providerSetupSources = [
 		benchmarkConcurrency: 20,
 		defaultEndpoint: "https://openrouter.ai/api/v1",
 		defaultProviderId: "openrouter",
+		kind: "openai-compatible",
 		label: "OpenRouter",
 		probeModels: true,
 		value: "openrouter"
@@ -318,6 +322,7 @@ const providerSetupSources = [
 		benchmarkConcurrency: 2,
 		defaultEndpoint: "https://api.cerebras.ai/v1",
 		defaultProviderId: "cerebras",
+		kind: "openai-compatible",
 		label: "Cerebras",
 		probeModels: true,
 		value: "cerebras"
@@ -326,6 +331,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 +339,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 +451,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 +592,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 +632,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,17 +717,105 @@ 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.";
 	return `unknown provider "${escapeLineValue(providerId)}" in ${scope} setup config.${hint}\n`;
 }
 async function loadMergedSetupConfig(io) {
-	const globalSetupConfigPath = getGlobalSetupConfigPath(io.env ?? process.env);
-	const projectSetupConfigPath = getProjectSetupConfigPath(io.cwd);
-	const [globalSetupConfig, projectSetupConfig] = await Promise.all([loadSetupConfig(globalSetupConfigPath), loadSetupConfig(projectSetupConfigPath)]);
+	const { globalSetupConfig, projectSetupConfig } = await loadSetupConfigs(io);
 	return mergeSetupConfigs(globalSetupConfig, projectSetupConfig);
 }
+async function loadRunSetupConfig(io) {
+	const { globalSetupConfig, projectSetupConfig } = await loadSetupConfigs(io);
+	return {
+		defaultModel: projectSetupConfig.providers.some((provider) => provider.models.length > 0) ? void 0 : "default",
+		setupConfig: mergeSetupConfigs(globalSetupConfig, projectSetupConfig)
+	};
+}
 async function loadScopedSetupConfig(io, local) {
 	const scope = local === true ? "local" : "global";
 	const path = scope === "local" ? getProjectSetupConfigPath(io.cwd) : getGlobalSetupConfigPath(io.env ?? process.env);
@@ -665,6 +825,15 @@ async function loadScopedSetupConfig(io, local) {
 		scope
 	};
 }
+async function loadSetupConfigs(io) {
+	const globalSetupConfigPath = getGlobalSetupConfigPath(io.env ?? process.env);
+	const projectSetupConfigPath = getProjectSetupConfigPath(io.cwd);
+	const [globalSetupConfig, projectSetupConfig] = await Promise.all([loadSetupConfig(globalSetupConfigPath), loadSetupConfig(projectSetupConfigPath)]);
+	return {
+		globalSetupConfig,
+		projectSetupConfig
+	};
+}
 //#endregion
 //#region src/cli/commands/config/models/benchmark-progress.ts
 /** Keeps the benchmark preview live without mixing transient frames into the final stdout table. */
@@ -806,19 +975,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;
@@ -927,15 +1098,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;
@@ -1536,7 +1713,7 @@ function createProviderEditorPrompts(prompts) {
 		async headerInput() {
 			return textResult(prompts, await prompts.text({
 				message: "Headers (leave empty to skip; type .. to go back)",
-				placeholder: "Authorization=Bearer token, X-Test=true",
+				placeholder: "Authorization=Bearer sk-or-v1-xxxxxx, X-Test=true",
 				validate: (value) => {
 					if (isBackInput(value ?? "")) return;
 					try {
@@ -1655,6 +1832,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), {}) ?? {};
@@ -1786,6 +1964,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,
@@ -1805,7 +2007,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)}`,
@@ -1818,6 +2020,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);
 }
@@ -1871,6 +2154,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));
@@ -1880,12 +2168,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;
@@ -1933,13 +2221,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);
@@ -3421,7 +3717,7 @@ 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 [{ defaultModel, setupConfig }, config] = await Promise.all([loadRunSetupConfig(io), loadAlintConfig(io.cwd, options.config)]);
 	let lintTargets;
 	try {
 		lintTargets = await findLintTargets({
@@ -3456,42 +3752,48 @@ async function runLintCommand(files, options, io, interceptConsoleOutput) {
 	const writeResult = (runResult) => {
 		io.stdout.write(formatDiagnostics(options.format, runResult, { color: io.stdout.isTTY === true }));
 	};
+	const runtime = await startModelAdapters(setupConfig, io);
 	let result;
 	try {
-		result = await runAlint({
-			cacheOnly: options.cacheOnly,
-			config,
-			cwd: io.cwd,
-			directories: lintTargets.directories,
-			files: lintTargets.files,
-			modelOverride: options.model,
-			outputLanguage: options.outputLanguage,
-			progress: mergeProgressReporters(progress?.reporter, statsCollector?.reporter),
-			runner,
-			setupConfig
-		});
-	} catch (error) {
+		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: runtime.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;
+		}
 		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 runtime.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;
@@ -3660,7 +3962,7 @@ async function runInteractiveSetup(io) {
 					label: "Global",
 					value: "global"
 				}, {
-					label: "Local project",
+					label: "Local project - Warning: You are about to store your credentials in the folder",
 					value: "local"
 				}]
 			});

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-CL433bER.mjs";
+import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-DFWnPI6m.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/package.json

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