@alint-js/cli 0.4.0 → 0.6.0

package/dist/index.d.mts

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

package/dist/index.mjs

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

@@ -0,0 +1,368 @@
+import { a as createRunSession } from "./cli-cQihuHqx.mjs";
+import { realpath } from "node:fs/promises";
+import { AlintRunCancelledError, AlintRunError } from "@alint-js/core";
+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";
+//#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, { 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);
+			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,
+			inputs: options.inputs,
+			projectTargets: options.inputs === 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,22 @@
 {
   "name": "@alint-js/cli",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.6.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",
@@ -21,22 +36,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",
-    "@alint-js/model-adapter-acp": "0.4.0",
-    "@alint-js/core": "0.4.0",
-    "@alint-js/config": "0.4.0"
+    "vscode-languageserver": "^10.1.0",
+    "@alint-js/config": "0.6.0",
+    "@alint-js/core": "0.6.0",
+    "@alint-js/utils": "0.6.0",
+    "@alint-js/model-adapter-acp": "0.6.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",