@alint-js/cli 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as formatJson, i as formatStylish, r as formatDiagnostics, t as executeCli } from "./cli-ChymU1Wr.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-DgJa6R5l.mjs → server-C-kuoGl1.mjs}

@@ -1,8 +1,9 @@
-import { n as createRunSession } from "./cli-ChymU1Wr.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 { join, relative, sep } from "node:path";
 import { errorMessageFrom } from "@moeru/std";
+import { join, relative, sep } from "node:path";
 import { Writable } from "node:stream";
 import { DidChangeWatchedFilesNotification } from "vscode-languageserver";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -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,8 +150,8 @@ async function createFolderSession(options) {
 		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);
+			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);
 			if (!found.has(documentUri) && diagnostics.delete(documentUri)) changed.add(documentUri);
@@ -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`);
@@ -159,8 +205,8 @@ async function runFromCache(session, options = {}) {
 	try {
 		return await session.run({
 			cacheOnly: true,
-			files: options.files,
-			projectTargets: options.files === void 0 ? void 0 : false,
+			inputs: options.inputs,
+			projectTargets: options.inputs === void 0 ? void 0 : false,
 			runner: {
 				...session.runner,
 				stats: false
@@ -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,12 +1,31 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.7.0",
+  "description": "Agentic code analysis CLI for model-backed lint rules",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moeru-ai/alint.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "alint",
+    "lint",
+    "linter",
+    "ai",
+    "code-analysis",
+    "cli"
+  ],
   "exports": {
     ".": {
       "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": {
@@ -21,23 +40,25 @@
     "cac": "^7.0.0",
     "cli-spinners": "^3.4.0",
     "date-fns": "^4.4.0",
+    "diff": "^9.0.0",
     "fast-string-truncated-width": "^3.0.3",
     "fast-string-width": "^3.0.2",
     "gitignore-fs": "^2.2.3",
     "minimatch": "^10.2.6",
     "pathe": "^2.0.3",
     "table": "^6.9.0",
+    "tinyexec": "^1.2.4",
     "tinyrainbow": "^3.1.1",
     "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"
+    "@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",
     "local-pkg": "^1.2.1",
-    "mlly": "^1.8.2",
-    "tinyexec": "^1.2.4"
+    "mlly": "^1.8.2"
   },
   "scripts": {
     "alint": "node ./dist/bin/index.mjs",