@alint-js/cli 0.6.0 → 0.7.0

package/README.md

@@ -219,18 +219,17 @@ 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 on stdin and stdout. Any editor with LSP support can
+use it.
 
-`alint lsp` runs alint as a language server over stdin and stdout.
+The server is cache-first. It publishes diagnostics that earlier runs stored, and it never calls a
+model on its own, so opening a workspace costs nothing. A cold cache shows no diagnostics. Run
+`alint` once to fill it.
 
-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.
+Diagnostics appear when the editor opens the workspace, and they refresh when you save a file. The
+server reloads `alint.config.ts` after it changes.
 
-Point any LSP editor at the command. In Neovim:
+Configure the editor to start the command. In Neovim:
 
 ```lua
 vim.lsp.config.alint = {
@@ -239,20 +238,23 @@ vim.lsp.config.alint = {
 }
 ```
 
-The server declares two commands, `alint.runFile` and `alint.runWorkspace`, which will start runs
-that call models and spend tokens. Both return `MethodNotFound` today.
+The server declares three commands. `alint.runFile` and `alint.runWorkspace` start runs that call
+models and spend tokens; both report progress and accept cancellation. `alint.clearCache` deletes
+the cached diagnostics.
 
-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:
+#### VS Code
+
+The extension in `apps/vscode` starts the server and displays 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
+code --extensionDevelopmentPath=apps/vscode/dist /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.
+The extension finds the alint executable in this order: the `alint.path` setting, then
+`node_modules/.bin/alint` in the workspace folder, then `PATH`. The workspace installation takes
+precedence, so the server and a terminal run use the same cache.
 
 ### Codex stop-gate plugin (optional)
 

package/dist/bin/index.mjs

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

package/dist/{cli-cQihuHqx.mjs → cli-BsBgbtds.mjs}

@@ -3,7 +3,7 @@ import { inspect } from "node:util";
 import { cac } from "cac";
 import { appendFile, chmod, mkdir, opendir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { addProviderModels, getGlobalSetupConfigPath, getProjectSetupConfigPath, getStatsDir, installStaticPlugins, isAcpModel, loadAlintConfig, loadAlintConfigWithMetadata, loadSetupConfig, mergeSetupConfigs, normalizeSetupConfig, pruneProviderModels, removeProviderModels, replaceSetupProvider, setProviderEndpoint, setProviderHeader, setStopGateConfig, unsetProviderHeader, writeSetupConfig } from "@alint-js/config";
-import { AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, defaultStopGateConfig, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, resolveConfigForDirectory, resolveConfigForFile, resolveStopGateConfig, runAlint, stableHash } from "@alint-js/core";
+import { AlintCachePersistenceError, AlintRunCancelledError, AlintRunError, benchmarkModels, defaultStopGateConfig, hasDiscoveryFilePatterns, matchesDiscoveryFile, maximumStopGateTimeoutMs, normalizeConfig, normalizeRunnerCacheConfig, resolveConfigForDirectory, resolveConfigForFile, resolveStopGateConfig, runAlint, stableHash } from "@alint-js/core";
 import { isAbsolute, join, relative, resolve } from "pathe";
 import { errorMessageFrom } from "@moeru/std";
 import { errorMessageFrom as errorMessageFrom$1 } from "@moeru/std/error";
@@ -24,7 +24,7 @@ import { Minimatch, minimatch } from "minimatch";
 import fastStringTruncatedWidth from "fast-string-truncated-width";
 import { formatDuration, intervalToDuration } from "date-fns";
 //#region package.json
-var version = "0.6.0";
+var version = "0.7.0";
 //#endregion
 //#region src/cli/output.ts
 function escapeLineValue(value) {
@@ -2877,7 +2877,7 @@ function mergeRunnerConfigs(setupRunner, configRunner) {
 	};
 	return Object.values(runner).some((value) => value !== void 0) ? runner : void 0;
 }
-/** The last `runner` block in the flattened config wins, key by key. */
+/** The last `runner` block in the flattened config takes precedence, key by key. */
 function resolveConfigRunner(config) {
 	return normalizeConfig(config).reduce((merged, item) => item.runner ? {
 		...merged,
@@ -2915,7 +2915,9 @@ async function createRunSession(io, options = {}) {
 	const runtime = await (options.startModelAdapters ?? startModelAdapters)(fileSetupConfig, io);
 	const { setupConfig } = runtime;
 	let shutdown;
+	const runner = mergeRunnerConfigs(setupConfig.runner, resolveConfigRunner(config));
 	return {
+		cache: normalizeRunnerCacheConfig(runner?.cache, io.cwd),
 		config,
 		cwd: io.cwd,
 		defaultModel,
@@ -2943,7 +2945,7 @@ async function createRunSession(io, options = {}) {
 				signal: runOptions.signal
 			});
 		},
-		runner: mergeRunnerConfigs(setupConfig.runner, resolveConfigRunner(config)),
+		runner,
 		setupConfig,
 		shutdown: () => shutdown ??= runtime.shutdown()
 	};
@@ -4485,10 +4487,10 @@ function shouldEnableProgress(options, io) {
 //#endregion
 //#region src/cli/commands/lsp/index.ts
 const lsp = defineCommand({
-	action: async (context) => (await import("./server-xx0w7UQL.mjs")).startLspServer(context.io),
+	action: async (context) => (await import("./server-C-kuoGl1.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"),
+	help: ["Serve alint diagnostics over the Language Server Protocol on stdin/stdout.", "The server is cache-first. It publishes diagnostics that are already cached, and it 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)",

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-cQihuHqx.mjs";
+import { i as formatJson, n as formatDiagnostics, r as formatStylish, t as executeCli } from "./cli-BsBgbtds.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/lsp-commands.d.mts

@@ -0,0 +1,16 @@
+//#region src/cli/commands/lsp/command-ids.d.ts
+/**
+ * Command ids the language server declares in `executeCommandProvider`.
+ *
+ * They are part of the protocol surface, so any editor integration needs them, not only the VS
+ * Code extension in this repository. This module imports nothing, so a client can bundle it
+ * without pulling in the CLI.
+ */
+/** Deletes cached diagnostics. A client asks the user before it sends this. */
+declare const CLEAR_CACHE_COMMAND = "alint.clearCache";
+/** Runs one file. The argument is the document URI. */
+declare const RUN_FILE_COMMAND = "alint.runFile";
+/** Runs every file the config matches. It takes no arguments. */
+declare const RUN_WORKSPACE_COMMAND = "alint.runWorkspace";
+//#endregion
+export { CLEAR_CACHE_COMMAND, RUN_FILE_COMMAND, RUN_WORKSPACE_COMMAND };

package/dist/lsp-commands.mjs

@@ -0,0 +1,16 @@
+//#region src/cli/commands/lsp/command-ids.ts
+/**
+* Command ids the language server declares in `executeCommandProvider`.
+*
+* They are part of the protocol surface, so any editor integration needs them, not only the VS
+* Code extension in this repository. This module imports nothing, so a client can bundle it
+* without pulling in the CLI.
+*/
+/** Deletes cached diagnostics. A client asks the user before it sends this. */
+const CLEAR_CACHE_COMMAND = "alint.clearCache";
+/** Runs one file. The argument is the document URI. */
+const RUN_FILE_COMMAND = "alint.runFile";
+/** Runs every file the config matches. It takes no arguments. */
+const RUN_WORKSPACE_COMMAND = "alint.runWorkspace";
+//#endregion
+export { CLEAR_CACHE_COMMAND, RUN_FILE_COMMAND, RUN_WORKSPACE_COMMAND };

package/dist/{server-xx0w7UQL.mjs → server-C-kuoGl1.mjs}

@@ -1,5 +1,6 @@
-import { a as createRunSession } from "./cli-cQihuHqx.mjs";
-import { realpath } from "node:fs/promises";
+import { a as createRunSession } from "./cli-BsBgbtds.mjs";
+import { CLEAR_CACHE_COMMAND, RUN_FILE_COMMAND, RUN_WORKSPACE_COMMAND } from "./lsp-commands.mjs";
+import { realpath, rm } from "node:fs/promises";
 import { AlintRunCancelledError, AlintRunError } from "@alint-js/core";
 import { errorMessageFrom } from "@moeru/std";
 import { join, relative, sep } from "node:path";
@@ -90,12 +91,51 @@ async function createFolderSession(options) {
 	let session = await createRunSession(runIo);
 	let diagnostics = /* @__PURE__ */ new Map();
 	let scheduled;
+	let explicitRun = Promise.resolve();
+	let explicitRunning = false;
 	const replaceMap = (next) => {
 		const changed = /* @__PURE__ */ new Set([...next.keys(), ...diagnostics.keys()]);
 		diagnostics = next;
 		return [...changed];
 	};
+	const runOnce = async (runOptions) => {
+		const runPaths = runOptions.inputs?.map((uri) => toRunPath(uri, paths)).filter((path) => path !== void 0);
+		const changed = /* @__PURE__ */ new Set();
+		const merge = (result) => {
+			for (const [uri, list] of groupByUri(result, paths)) {
+				diagnostics.set(uri, list);
+				changed.add(uri);
+			}
+		};
+		explicitRunning = true;
+		try {
+			merge(await session.run({
+				inputs: runPaths,
+				progress: {
+					onDiagnostic: ({ diagnostic }) => {
+						const uri = toDocumentUri(diagnostic.filePath, paths);
+						diagnostics.set(uri, [...diagnostics.get(uri) ?? [], toLspDiagnostic(diagnostic)]);
+						changed.add(uri);
+					},
+					onJobStart: ({ job, progress }) => runOptions.onProgress?.(progress, job.inputPath)
+				},
+				projectTargets: runPaths === void 0 ? void 0 : false,
+				runner: session.runner,
+				signal: runOptions.signal
+			}));
+		} catch (error) {
+			if (!(error instanceof AlintRunError) && !(error instanceof AlintRunCancelledError)) throw error;
+			merge(error.result);
+		} finally {
+			explicitRunning = false;
+			if (changed.size > 0) options.onChanged?.([...changed]);
+		}
+	};
 	return {
+		clearCache: async () => {
+			await rm(session.cache.location, { force: true });
+			return replaceMap(/* @__PURE__ */ new Map());
+		},
 		cwd,
 		get diagnostics() {
 			return diagnostics;
@@ -110,7 +150,7 @@ async function createFolderSession(options) {
 		folderUri: options.folderUri,
 		refreshFile: async (uri) => {
 			const filePath = toRunPath(uri, paths);
-			if (filePath === void 0) return [];
+			if (filePath === void 0 || explicitRunning) return [];
 			const found = groupByUri(await runFromCache(session, { inputs: [filePath] }), paths);
 			const changed = /* @__PURE__ */ new Set([...found.keys()]);
 			const documentUri = toDocumentUri(filePath, paths);
@@ -119,6 +159,7 @@ async function createFolderSession(options) {
 			return [...changed];
 		},
 		refreshFromCache: async () => {
+			if (explicitRunning) return;
 			replaceMap(groupByUri(await runFromCache(session), paths));
 		},
 		reloadConfig: async () => {
@@ -126,12 +167,17 @@ async function createFolderSession(options) {
 			session = await createRunSession(runIo);
 			await replaced.shutdown();
 		},
+		runExplicit: (runOptions) => {
+			explicitRun = explicitRun.catch(() => {}).then(() => runOnce(runOptions));
+			return explicitRun;
+		},
 		scheduleWorkspacePass: () => {
 			if (scheduled !== void 0) return;
 			scheduled = setTimeout(() => {
 				scheduled = void 0;
 				(async () => {
 					try {
+						if (explicitRunning) return;
 						options.onChanged?.(replaceMap(groupByUri(await runFromCache(session), paths)));
 					} catch (error) {
 						options.io.stderr.write(`alint lsp: workspace pass failed: ${errorMessageFrom(error) ?? "unknown error"}\n`);
@@ -197,9 +243,9 @@ function toRunPath(uri, paths) {
 /**
 * 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.
+* An LSP publish contains a whole document, so one publish per diagnostic 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();
@@ -238,9 +284,6 @@ function createPublisher(options) {
 //#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) {
@@ -282,7 +325,11 @@ async function startLspServer(io) {
 		watchesConfig = params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
 		return { capabilities: {
 			executeCommandProvider: {
-				commands: [RUN_FILE_COMMAND, RUN_WORKSPACE_COMMAND],
+				commands: [
+					CLEAR_CACHE_COMMAND,
+					RUN_FILE_COMMAND,
+					RUN_WORKSPACE_COMMAND
+				],
 				workDoneProgress: true
 			},
 			textDocumentSync: {
@@ -302,7 +349,7 @@ async function startLspServer(io) {
 			try {
 				await openFolder(folderUri);
 			} catch (error) {
-				connection.console.error(`alint: ${folderUri}: ${errorMessageFrom(error) ?? "could not read cached diagnostics"}`);
+				connection.console.error(`${folderUri}: ${errorMessageFrom(error) ?? "could not read cached diagnostics"}`);
 			}
 		}));
 	});
@@ -311,7 +358,7 @@ async function startLspServer(io) {
 			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.console.error(`${textDocument.uri}: ${errorMessageFrom(error) ?? "could not refresh the saved file"}`);
 			}
 		}));
 	});
@@ -322,16 +369,55 @@ async function startLspServer(io) {
 	connection.onDidCloseTextDocument(({ textDocument }) => {
 		publisher.setOpen(textDocument.uri, false);
 	});
+	connection.onExecuteCommand(async ({ arguments: args, command }) => {
+		if (command === "alint.clearCache") {
+			await Promise.all([...folders.values()].map(async (folder) => {
+				try {
+					for (const uri of await folder.clearCache()) publisher.queue(uri);
+				} catch (error) {
+					connection.console.error(`${folder.folderUri}: ${errorMessageFrom(error) ?? "could not clear the cache"}`);
+				}
+			}));
+			return;
+		}
+		const inputs = command === "alint.runFile" ? args?.filter((value) => typeof value === "string") : void 0;
+		if (command === "alint.runFile" && (inputs === void 0 || inputs.length === 0)) {
+			connection.console.error(`${RUN_FILE_COMMAND} needs a document URI.`);
+			return;
+		}
+		const reporter = await connection.window.createWorkDoneProgress();
+		const controller = new AbortController();
+		reporter.begin(inputs === void 0 ? "Running alint on the workspace" : "Running alint on the current file", 0, void 0, true);
+		reporter.token.onCancellationRequested(() => controller.abort());
+		try {
+			await Promise.all([...folders.values()].map(async (folder) => {
+				try {
+					await folder.runExplicit({
+						inputs,
+						onProgress: (progress, inputPath) => {
+							const percentage = progress.jobsTotal === 0 ? 0 : Math.round(progress.jobsCompleted / progress.jobsTotal * 100);
+							reporter.report(percentage, inputPath);
+						},
+						signal: controller.signal
+					});
+				} catch (error) {
+					connection.console.error(`${folder.folderUri}: ${errorMessageFrom(error) ?? "the run failed"}`);
+				}
+			}));
+		} finally {
+			reporter.done();
+		}
+	});
 	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.error(`${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.console.info("Configuration changed. Cached diagnostics were cleared. Run alint again to recreate them.");
 	});
 	connection.onShutdown(async () => {
 		publisher.dispose();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Agentic code analysis CLI for model-backed lint rules",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,10 @@
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
+    "./lsp-commands": {
+      "types": "./dist/lsp-commands.d.mts",
+      "default": "./dist/lsp-commands.mjs"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
@@ -46,10 +50,10 @@
     "tinyexec": "^1.2.4",
     "tinyrainbow": "^3.1.1",
     "vscode-languageserver": "^10.1.0",
-    "@alint-js/config": "0.6.0",
-    "@alint-js/core": "0.6.0",
-    "@alint-js/utils": "0.6.0",
-    "@alint-js/model-adapter-acp": "0.6.0"
+    "@alint-js/model-adapter-acp": "0.7.0",
+    "@alint-js/core": "0.7.0",
+    "@alint-js/config": "0.7.0",
+    "@alint-js/utils": "0.7.0"
   },
   "devDependencies": {
     "@pnpm/find-workspace-dir": "^1000.1.5",